Are you an LLM? Read llms.txt for a summary of the docs, or llms-full.txt for the full context.
Skip to content

What is agentful?

agentful is a Claude Code configuration that adds specialized agents, quality gates, and structured workflows to your development process. It transforms how you build software by providing autonomous development capabilities while keeping you in control of key decisions.

Configure Your Installation →

Core Capabilities

agentful extends Claude Code with four key capabilities:

  1. Specialized Agents - Backend, frontend, testing, review, orchestration
  2. Quality Gates - Type checking, linting, test coverage, dead code detection
  3. Product Tracking - Feature status, completion percentage, blocking decisions
  4. Smart Analysis - Tech stack detection, pattern recognition, domain discovery

It's a .claude/ directory structure with agents, commands, and skills that Claude Code loads automatically.

Agent Architecture

Claude Code runs with different instruction sets depending on which agent you invoke. Each agent has explicit scope boundaries and responsibilities:

Core Agents

  • @orchestrator - Coordinates work, delegates to specialists, never writes code directly
  • @architect - Analyzes tech stack, generates domain-specific agents
  • @backend - Server-side logic, APIs, databases
  • @frontend - UI components, state management, client code
  • @tester - Test generation and execution
  • @reviewer - Quality validation, security checks
  • @fixer - Automated remediation of failures

Specialized Agents

Beyond core agents, agentful can generate domain-specific agents based on your codebase:

  • @auth-agent - Authentication and authorization patterns
  • @payment-agent - Payment processing and billing
  • @notification-agent - Email, SMS, push notifications
  • Custom agents - Generated from your business logic

Each agent knows when to delegate to others and when a task is outside their scope.

Multi-Agent Distribution

The orchestrator acts as the central coordinator, analyzing tasks and delegating to specialist agents based on the work required:

Click to expand
How it works:
  1. You invoke /agentful-start with a task
  2. Orchestrator classifies the work type (feature, bugfix, refactor, etc.)
  3. Delegates to appropriate specialist agents in parallel when possible
  4. Agents complete their work and report back
  5. Reviewer validates against quality gates
  6. Fixer auto-remediates any failures
  7. Progress is tracked and state is updated

Development Workflow

The typical agentful workflow follows this pattern:

1. Define Product Specification

Create a structured product spec in .claude/product/:

## Overview
Task management for distributed teams
 
## Tech Stack
- Next.js 14 + TypeScript
- Prisma + PostgreSQL
- Vitest + Playwright
 
## Features
1. Authentication (CRITICAL)
2. Project management (HIGH)
3. Task assignment (MEDIUM)

2. Detect Tech Stack & Generate Agents

agentful automatically detects your tech stack and generates:

  • Domain-specific agents based on your business logic
  • Tech stack skills for framework patterns
  • Pattern-matched instructions from your actual code

3. Start Structured Development

Run /agentful-start to begin the automated development workflow.

Workflow Pipeline

The workflow follows these stages with automatic progression:

Click to expand

4. Human Checkpoints

The system pauses for your input on:

  • Architectural decisions
  • Library selection
  • Security configurations
  • API design choices
  • Database schema changes

You remain in control while Claude handles implementation details.

Quality Gates

All implementations are validated against six automated quality gates before deployment.

The 6 Gates

Every feature must pass all six gates:

Click to expand
Gate Details:
  • Type Checking - Zero TypeScript/Flow errors
  • Linting - Code follows style guide (ESLint, Biome, Ruff)
  • Tests - All test suites passing
  • Coverage - Minimum 80% code coverage
  • Security - No vulnerable dependencies
  • Dead Code - No unused exports or files

Gates adapt to your stack. The framework detects available tools and runs appropriate checks. When gates fail, the Fixer agent automatically attempts remediation.

How It Works

File Structure

agentful creates a specific directory structure in your project:

your-project/
├── CLAUDE.md               # Project context
├── .claude/                # Framework (version control)
│   ├── agents/
│   │   ├── orchestrator.md
│   │   ├── backend.md
│   │   ├── frontend.md
│   │   ├── tester.md
│   │   └── ephemeral/      # Generated agents (gitignored)
│   ├── commands/
│   │   ├── agentful-start.md
│   │   ├── agentful-status.md
│   │   └── agentful-validate.md
│   ├── skills/
│   │   ├── product-tracking/
│   │   └── validation/
│   ├── product/            # Product specification
│   │   ├── index.md
│   │   └── domains/
│   └── settings.json
└── .agentful/              # Runtime state (gitignored)
    ├── state.json
    ├── completion.json
    └── decisions.json

Version Control: .claude/ and CLAUDE.md Gitignore: .agentful/ and .claude/agents/ephemeral/

Tech Stack Detection

agentful automatically detects and adapts to your technology stack:

  • 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

The system generates appropriate patterns and validations based on what it detects.

New vs Existing Projects

New Projects (No Code Yet)

  1. Architect prompts for tech stack choices
  2. Generates template agents from best practices
  3. Implements first feature
  4. Re-analyzes actual code
  5. Updates agents with your specific patterns
  6. Continues with refined agents

The system learns from your actual code and refines its approach.

Existing Projects (With Code)

  1. Architect samples your codebase
  2. Detects patterns, conventions, and structure
  3. Generates agents matching your exact style
  4. Begins implementation following existing patterns

agentful adapts to your existing code rather than imposing new patterns.

Extended Development Sessions

Use the Ralph Wiggum plugin for extended sessions:

claude
/plugin install ralph-wiggum@anthropics
/ralph-loop "/agentful-start" --max-iterations 50

This runs multiple development iterations until the max is reached or the orchestrator completes its work.

What agentful Is Not

Important limitations to understand:

  • Not fully autonomous - Requires human decisions on architecture and design
  • Not a testing framework - Generates tests but needs infrastructure
  • Not a deployment system - Focused on development, not operations
  • Not a replacement for developers - Accelerates implementation, not strategy

Works best with:

  • Clear product specifications
  • Timely human decisions
  • Existing project structure (or willingness to define one)

Common Workflows

New Project from Scratch

npx @itz4blitz/agentful init
claude
/agentful-product          # Interactive spec creation
/agentful-start            # Begin development (auto-detects tech stack)
/agentful-status           # Check progress
/agentful-decide           # Answer blocking decisions

Existing Codebase

npx @itz4blitz/agentful init
claude
/agentful-product          # Reverse-engineer spec
/agentful-start            # Continue development (auto-detects tech stack)

Ad-hoc Questions

claude
/agentful "Should I use REST or GraphQL for this API?"

Next Steps

Now that you understand how agentful works:

  1. Configure Your Installation - Use the interactive configurator
  2. Quick Start Guide - Get up and running in 5 minutes
  3. Your First Project - Step-by-step tutorial
  4. Agent Details - Deep dive into each agent
  5. Command Reference - All available commands

Resources

Built on Claude Code by Anthropic.