Package Exports

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (@itz4blitz/agentful) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

agentful

Autonomous product development framework for Claude Code.

Overview

agentful is a Claude Code configuration that provides structured autonomous development through specialized AI agents. It coordinates multiple agents to implement features, write tests, and validate code quality according to a defined product specification.

Installation

npx @itz4blitz/agentful init

This command creates the necessary directory structure and configuration files in your project.

Usage

1. Define Product Specification

After initialization, edit your product specification file with features and requirements.

Flat structure (single file at project root):

PRODUCT.md - All features in one file

Hierarchical structure (organized by domain):

.claude/product/index.md - Product overview
.claude/product/domains/*/features/ - Feature definitions organized by domain

2. Start Development

claude  # Start Claude Code

Then use the /agentful-start command to begin autonomous development.

New Projects (No Existing Code)

For brand new projects with no code yet:

Tech Stack Selection: On first run, the architect agent will ask about your tech stack:
- Frontend framework (React, Vue, Next.js, etc.)
- Backend framework (Express, Django, Spring Boot, etc.)
- Database (PostgreSQL, MongoDB, MySQL, etc.)
- Additional tools (ORM, testing framework, styling)
Initial Agent Generation: Specialized agents are generated using best practices for your chosen stack:
- Based on official framework documentation
- Using common patterns and conventions
- Marked with confidence: 0.4 (template-based)
First Feature Implementation: The system builds your first feature using these template agents
Automatic Re-Analysis: After the first feature is complete:
- Architect re-analyzes your actual code
- Updates agents with your project's specific patterns
- Confidence increases (0.4 → 0.8+)
- Remaining features use refined, project-specific agents

Benefits:

✅ Start immediately without existing code
✅ No blocking on pattern detection
✅ Learns and adapts after first implementation
✅ Continuously improving agent quality

Existing Projects (With Code)

For projects with existing code:

Pattern Detection: Architect samples your codebase to detect:
- Language and framework
- File organization patterns
- Coding conventions
- Import/export styles
- Error handling patterns
Agent Generation: Creates specialized agents matching your exact conventions
- Real code examples from your project
- Your specific patterns and styles
- High confidence (0.8-1.0)

3. Monitor Progress

/agentful-status - View completion percentage and current work
/agentful-validate - Run quality checks
/agentful-decide - Answer blocking questions

Architecture

Agent System

agentful uses seven specialized agents:

Agent	Responsibility
orchestrator	Coordinates work, routes tasks, tracks state
architect	Analyzes project structure and generates specialized agents • New projects: Prompts for tech stack, generates template agents • Existing projects: Detects patterns from code • Re-analyzes after first implementation in new projects
backend	Implements server-side logic, APIs, database schemas
frontend	Implements UI components, pages, state management
tester	Writes unit, integration, and end-to-end tests
reviewer	Validates code quality, security, and standards
fixer	Resolves validation failures and test errors

Quality Gates

Code changes are validated against:

Type checking (TypeScript, Flow, etc.)
Linting (ESLint, Biome, etc.)
Test execution (all tests must pass)
Code coverage (minimum 80%)
Security scanning
Dead code detection

State Tracking

Runtime state is stored in .agentful/:

state.json - Current task and phase
completion.json - Feature completion status
decisions.json - Pending and resolved decisions
architecture.json - Technology stack (declared or detected)
- New projects: Starts with declared stack (confidence: 0.4)
- Existing projects: Detected from code (confidence: 0.8-1.0)
- Re-analyzed after first implementation in new projects

Commands

Command	Description
`/agentful-start`	Start or resume autonomous development
`/agentful-status`	Display progress and current state
`/agentful-validate`	Run all quality checks
`/agentful-decide`	Answer pending decisions

Technology Support

agentful detects and adapts to your technology stack automatically:

Languages: TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, Elixir
Frontend: React, Vue, Angular, Svelte, Next.js, Astro, SolidJS
Backend: Express, Fastify, NestJS, Hono, Next.js API Routes
Databases: PostgreSQL, MySQL, SQLite, MongoDB
ORMs: Prisma, Drizzle, TypeORM, Mongoose
Testing: Jest, Vitest, Playwright, Cypress, Pytest, JUnit

Requirements

Claude Code (code.anthropic.com)
Node.js 22 or higher
Git

Documentation

Full documentation: agentful.app

Project Structure

your-project/
├── PRODUCT.md                      # Product specification (flat)
├── CLAUDE.md                       # Project instructions
├── .claude/
│   ├── product/                    # Product specification (hierarchical)
│   ├── agents/                     # Agent definitions
│   ├── commands/                   # Slash commands
│   ├── skills/                     # Reusable skills
│   └── settings.json               # Configuration
├── .agentful/                      # Runtime state
│   ├── state.json
│   ├── completion.json
│   ├── decisions.json
│   └── architecture.json
└── src/                            # Source code

License

MIT

@itz4blitz/agentful