Your time back.That's the product.

AFK — away from keyboard. Today's AI coding tools are powerful, but they need you there the whole time: prompting, reviewing, re-explaining context, fixing mistakes, managing files. You're doing the work of a project manager, architect, and QA engineer just to get the AI to write code.

AFK coding flips this. You focus on what only you can do — describing what to build, making product decisions, defining acceptance criteria. The system handles everything else: planning, context assembly, implementation, testing, verification. It runs for hours without intervention, with the same quality on the last task as the first.

No re-explaining. No context pollution. No skipped tests. Every input creates a feature with its own plan, tasks, tests, and branch — not a chat session. You spend your time where it creates the most value. The engineering runs in the background. Read more about AFK coding →

You define what you want to build, answer a few clarifying questions, and click Execute. Every feature gets its own requirements, blueprint, task breakdown, git branch, and verification — not a conversation thread. The system handles everything else:

• Planning — analyzes your codebase, generates a requirements doc, technical blueprint, and task breakdown
• Execution — implements each task autonomously with a fresh AI session and curated context
• Verification — writes and runs tests at integration boundaries
• Review — you review diffs, ask questions, report bugs, then merge with one click

Your active time: about 10 minutes. The system does the rest. See the full feature lifecycle →

Claude (Anthropic), Codex (OpenAI), Gemini (Google), Kimi (Moonshot), and any model accessible through OpenCode. Use your existing subscription or API keys — your keys, your rates, zero markup.

Each activity in the pipeline (analysis, planning, execution, testing, review) can use a different provider and model. Use Claude Opus for architecture, Codex for implementation, a lightweight model for classification — all within the same feature. See supported providers and recommended models →

Afkode is built for work where planning, context, and testing matter. The more complex the feature, the more value you get:

• Multi-component features (auth, billing, dashboards)
• Full-stack work that crosses frontend, backend, and database
• Refactors that touch many files
• Batches of related bug fixes
• Repetitive work that needs consistency across many files

For simple one-file changes, use your IDE directly. Afkode is designed for the features that take days, not minutes. See the full use case guide →

Those tools are coding assistants — you guide every step, review each change, and re-explain your codebase every session.

Afkode is different: you describe what you want, approve the plan, and leave. The system executes autonomously through dozens of tasks, each with a fresh AI session and curated context. No context window pollution. No degradation. Task 50 runs with the same precision as task 1. See how the feature lifecycle works →

Every feature goes through a structured verification loop. The system checks each acceptance criterion against the implementation, writes targeted tests (unit, integration, and e2e), runs them, and reports coverage — which criteria passed and which have gaps.

Quality assurance starts before coding: the planning process produces traceable requirements and acceptance criteria. By the time code reaches your main branch, it has been planned, implemented, tested, and verified. Learn about the verification loop →

Yes — full visibility throughout:

• During planning: a phase stepper shows which step is active, with live streaming and section-by-section document generation
• During execution: the task sidebar shows what's done, what's running, and what's left — with subtask-level progress
• After each task: full code diff, execution log, and tool activity are available for review

You can navigate freely between views at any time. Learn about visibility →

When execution completes, a review panel opens. You interact through a single conversation — the system detects what you need automatically:

• Ask questions about the implementation → read-only Q&A
• Report a bug → guided fix with confirmation before any changes
• Test locally → copy the worktree path and run your project from there
• Say "merge" → the system merges to main and pushes to your remote

Nothing touches your main branch until you explicitly approve. Deployment is handled by your own pipeline — we recommend auto-deploying from main. Learn about the review flow →

Everything runs locally on your computer. Your code never touches our servers.

Afkode spawns each AI provider's official CLI directly on your machine. Your API keys and tokens stay local. Prompts go directly from your filesystem to the provider's API. We're not a middleman — we're a workflow layer running entirely on your device. Learn how Afkode runs AI locally →

Yes. Each feature gets its own git worktree and branch, fully isolated. You can plan and execute multiple features at the same time — even across different projects.

Parallel works best when features touch different parts of the codebase. For overlapping work (same files, same components), combine them into one larger request. The system handles any complexity. Learn about parallel development →

The system is designed for resilience at every level:

• Your main branch is always protected. Every feature runs in its own isolated workspace. Nothing is modified until you merge.
• Crashes are handled. All state is persisted locally. If your computer crashes or you close the app, you resume from exactly where you left off.
• Bugs are fixable. If you find an issue, describe it in the review chat. The AI investigates, explains the root cause, and applies an atomic fix after your confirmation.
• Test before merging. You can navigate to the worktree directory and run the project locally to verify everything works before merging to main.

Learn about protected workspaces →