↑ai transforms into always improving
zero-config ai development environment.
detect stack. install skills. ship code. stack agnostic.
$ ai-factory init
// detecting project stack...
[✓] next.js 14 + typescript detected
[✓] 20 skills installed
[✓] mcp servers configured
[✓] claude code integration ready
factory initialized. you're ready to build. ✨
// development_workflow
ai follows a plan, not random exploration
$ /aif
creates project context
and skill configuration
→
[✓] .ai-factory/DESCRIPTION.md
[✓] .ai-factory/ARCHITECTURE.md
[✓] .ai-factory/ROADMAP.md
[✓] .ai-factory/RULES.md
[✓] AGENTS.md
[✓] skills + mcp configured
01
$ /aif-roadmap
$ /aif-plan [fast|full]
$ /aif-improve
strategic milestones, detailed task
breakdowns, dependency refinement
02
$ /aif-implement
$ /aif-fix
tasks with commit checkpoints,
patches for self-improvement
04
$ /aif-evolve
analyzes accumulated patches,
improves skill capabilities
03
$ /aif-verify [--strict]
$ /aif-loop
validates against plan, reflex loop:
PLAN → PRODUCE → EVALUATE → REFINE
plan→implement→verify→commit→evolve
// new_project_workflow
complete step-by-step guide for any new project
$ npm i -g ai-factory
install ai-factory globally
$ ai-factory init
detect stack, install skills, configure mcp servers
open your ai agent
claude code, cursor, windsurf — any supported agent
$ /aif
initialize project structure and primary configuration
write your requirements
the most important step. think it through carefully.
use llm to refine and structure your spec
[!] quality of output = quality of input
$ /aif-roadmap
decompose requirements into milestones with clear deliverables
$ /aif-plan
plan milestone — create branch, detailed tasks, dependencies
$ /aif-improve
refine the plan — fix gaps, verify dependencies
[optional but recommended]
$ /aif-implement
execute task by task with commit checkpoints
$ /aif-verify
validate: everything done, nothing forgotten
$ /aif-fix
problems? fix them
$ /aif-commit
all good? commit
merge to main
return to main branch, merge the feature
// why_workflow
structured workflow costs more upfront but saves exponentially over time
token usage
"cheap" start, expensive rewrites
after feature
manually update docs, ci, contracts, configs
context
agent forgets decisions between sessions
bug fixing
re-explain everything from scratch each time
quality
random results, no verification step
automation
set up manually or forget about it
token usage
invest in planning, save on rewrites and fixes
after feature
docs, ci, contracts, automation — updated in the cycle
context
persistent specs: roadmap, plan, architecture
bug fixing
/aif-fix reads the plan and knows what was intended
quality
/aif-verify checks every task before commit
automation
ci, docker, build scripts — generated and maintained
spend ~20% more tokens on planning → save ~60% on fixes, rewrites, and context recovery
// core_features
> _
detects your stack automatically. no yaml, no json, no setup files. just works.
[ ]
ai follows structured plans. predictable, resumable, and reviewable workflows.
++
works with claude code, cursor, windsurf, copilot, gemini cli, and 10+ more agents.
$ /
leverage skills.sh marketplace. community-built extensions with security scanning.
{✓}
built-in logging, commit conventions, code review, and doc generation.
[!]
two-level security scanning for all external skills. safe by default.
// supported_agents
one factory, 15+ compatible agents
// aif_handoff
create a task — ai plans, implements, and reviews it. fully autonomous pipeline built on ai-factory.
⚡
drop a task in backlog — ai plans it, writes the code, reviews its own work, and ships. no babysitting required.
⚙
specialized coordinators for each stage. plan-polisher refines specs. parallel workers execute. review sidecars validate.
↻
heartbeat monitoring, automatic recovery from stuck stages, and rework loops when review catches issues.
◧
beautiful ui with drag-and-drop board, list view, real-time websocket updates, dark and light themes.
⊞
detects task dependencies automatically and dispatches parallel workers across independent layers.
☰
subagents mode for iterative refinement and higher quality. skills mode for fast single-pass execution.
built on ai-factory. powered by claude agent sdk.
// faq
use $ /aif-rules and add a rule like "after implementation, update API_REFERENCE.md and CHANGELOG.md". rules are executed automatically after each implementation cycle — so you never forget to keep your custom docs in sync.
planning takes ~20% more tokens upfront. but without a plan, agents waste tokens on wrong approaches, context recovery, and rewrites. structured workflow pays for itself within the first 2-3 features.
yes. run $ ai-factory init in any project — it detects your stack, installs relevant skills, and configures mcp servers. existing code stays untouched. you get the workflow on top of what you already have.
$ /aif-verify catches missed tasks and deviations from the plan. if something is wrong — $ /aif-fix reads the plan and knows exactly what was intended. each feature runs on a separate branch, so main stays clean.
no. the workflow is modular — skip what you don't need. small fix? just $ /aif-fix and $ /aif-commit. big feature? use the full cycle. the only step that's always recommended is $ /aif-verify before commit.
initialize ai-factory separately in each service — backend, frontend, every microservice gets its own $ ai-factory init with its own description, architecture, and skills. then add shared rules via $ /aif-rules describing how services communicate: api contracts, event schemas, shared types. each agent works in its own context but follows the same integration rules.
join 200+ developers using ai-factory to supercharge their workflow