npm install -g tasuki

Your AI coding assistant,
promoted to team lead.

One command transforms Claude Code into a team of 9 specialized engineers — automatic TDD, security audits, and a knowledge graph that gets smarter with every task.

Get started — it's free See the pipeline
npm install -g tasuki
$0 to onboard 8 AI tools MIT License Runs locally
Claude Code — your-project
$ tasuki onboard . ✓ FastAPI + PostgreSQL + React detected ✓ 9 agents configured · 3 hooks installed Ready. Talk to Claude Code normally.   You: Add user authentication with JWT   [Planner] → PRD designed · "Continue?" ✓ [QA] → 14 failing tests written (TDD) [DB Arch] → Migration: users, sessions, tokens [Backend] → JWT auth — 14/14 pass ✓ [Frontend] → Login/signup UI · all states [Security] → OWASP audit — PASS ✓ [Reviewer] → Code review — APPROVE ✓   ✓ Feature complete · $1.24 in API credits
The team you don't have to hire

9 engineers.
One command.

Each agent is a 250+ line production-hardened specialist. Hard boundaries, domain checklists, structured handoffs. See the full pipeline →

Planner
Stage 1
Designs architecture, writes PRDs, decomposes work into per-agent tasks. Waits for your confirmation before any code is written.
thinking · opus
QA
Stage 2
Writes failing tests before any code exists. The test IS the specification. The tdd-guard hook mechanically blocks implementation without tests.
execution · sonnet
DB Architect
Stage 3
Zero-downtime migrations in your exact format. Verifies the plan matches QA's tests before touching the schema.
execution · sonnet
Backend Dev
Stage 4
Runs failing tests first, then implements until all pass. APIs, services, background jobs. Structured handoff to Frontend.
execution · sonnet
Frontend Dev
Stage 5
Shows a design preview for your approval before building. Accessible, responsive UI with all states covered. Figma or generated.
execution · sonnet
Debugger
Stage 5.5
Reactive — only activates when tests fail. Max 5 diagnostic steps, then escalates. Never restarts from zero after a failed fix.
execution · sonnet
Security
Stage 6
Full OWASP Top 10:2025 audit. Variant analysis — finds one vuln, searches the entire codebase. Always runs. No excuses.
thinking · opus
Reviewer
Stage 7
Reads every changed file end-to-end. Cross-references models ↔ routes ↔ schemas ↔ tests. 3-round fix loop. Always runs.
thinking · opus
DevOps
Stage 8
Updates Docker, CI/CD, deploys, runs health checks via Sentry. Only activates when there are infrastructure changes to make.
execution · sonnet
How it works

Sequential by design,
not by accident.

Every stage has a reason to go exactly where it does. Frontend consumes Backend. You can't audit code that doesn't exist yet. Deep dive →

1
Planner
Confirms with you
Reads your project context, designs architecture, saves the PRD to tasuki-plans/. Decomposes into one task per agent via Taskmaster. Shows you the summary and waits before any code is written.
2
QA — tests first
TDD enforced
Writes failing tests before any implementation exists. The test is the specification. The tdd-guard hook mechanically blocks implementation code if no test file exists — exit code 2, no bypass.
3
DB Architect
Verifies the plan matches QA's tests before creating anything. Migration + model in production-safe DDL patterns: expand-contract for renames, batched defaults for large tables.
4
Backend Dev
Runs the failing tests first to confirm they fail for the right reason. Implements until all tests pass. Produces a structured handoff with every new endpoint, auth behavior, and env var needed by Frontend.
⚡ test checkpoint
all pass → continue · any fail → debugger
5
Frontend Dev
Design preview
Asks if you have a Figma file or want a generated preview before building. Builds responsive, accessible UI consuming verified backend endpoints. All states covered.
⚡ test checkpoint
all pass → security · any fail → debugger
6
Security
Always runs
OWASP Top 10:2025 full checklist, automated Semgrep scan, and variant analysis. Finds one vulnerability, searches the entire codebase for the same root cause pattern.
7
Reviewer
Always runs
Reads every changed file end-to-end, not just the diff. Cross-references models ↔ routes ↔ schemas ↔ tests. 3-round fix loop with regression detection after every change.
8–9
DevOps + Completion
Deploys if needed, health checks via Sentry, then writes a clean summary. Lessons learned save to the knowledge graph — the next task starts smarter.
Works with 8 AI tools

Built for Claude Code.
Compatible with the rest.

One onboard generates config for every tool. Claude Code gets full mechanical automation. Every other tool gets structured role-switching — still dramatically better than nothing.

Claude Code
Full pipeline
Pipeline execution
Automatic (Agent() sub-agents)
TDD hook
Mechanical block (exit 2)
Security hook
Mechanical block
Agent isolation
Separate context per agent
Memory vault
Full knowledge graph
Cursor · Codex · Copilot
+ Windsurf, Continue, Roo Code, Gemini
Compatible
Pipeline execution
Role-switching (guided)
TDD hook
Advisory rules
Security hook
Advisory rules
Agent isolation
Same context
Memory vault
Full knowledge graph
Memory

Not a RAG.
Something lighter.

Two layers of memory that get smarter with every task. No server, no embeddings pipeline, no infra. Just files. Full architecture →

Traditional RAG
Code → Chunking → Embeddings
→ Vector DB → Semantic search
→ LLM query → $$ per query

Needs: server, API keys, infra
Visibility: black box
Tasuki Memory
Code → Agent learns → writes .md
→ [[wikilinks]] connect knowledge
→ next run → reads only its memories

Layer 1: $0, offline, human-readable
Layer 2: on-demand, local SQLite
Layer 1 — Wikilinks
Each agent reads only its own memories via [[links]]. Backend Dev reads 18 memories → ~72 tokens. Zero extra cost.

Max 20 per agent · 4-dimension format · opens in Obsidian
Layer 2 — Deep Memory
Vector search over schema, APIs, plans, git history. Agent queries: "how do we handle auth?" → full models, endpoints, past PRDs.

Local SQLite · auto-syncs · 50+ entries · <50ms queries
Cost

Tasuki is free.
You pay for API credits.

The CLI is MIT open source. Onboarding is bash — $0, zero API calls. The only cost is your normal AI usage, made more efficient.

Fast fix
Small bugs, quick tweaks. Complexity 1–3.
~$0.26
~$0.15 – $0.50 per task
  • 3 agents (Planner, Dev, Reviewer)
  • ~18K tokens
  • Tests + security still run
  • Skips unused stages
tasuki mode fast
Standard feature
New endpoints, components, integrations. Complexity 5–6.
~$0.68
~$0.50 – $1.50 per task
  • 6 agents, full pipeline
  • ~46K tokens
  • TDD + OWASP audit
  • 3-round review loop
tasuki mode standard
Full feature
Complex features, auth systems. Complexity 8–10.
~$1–3
varies with retries & fix rounds
  • All 9 agents
  • ~71K tokens baseline
  • Debugger rounds if needed
  • Full variant analysis
tasuki mode serious

$50 in API credits ≈ 50–80 tasks ≈ roughly one month of active development.
~60% savings from model tiering · ~86% from filtered memory loading · ~40% from agent routing

FAQ

Common questions

No. Tasuki generates config files that your AI reads automatically. You ask for a feature the same way you always did — Tasuki changes how the AI responds. Think of it like ESLint: you don't say "hey ESLint", it just works.
Runs 5 bash detectors against your actual files — no API calls, zero tokens, $0. Detects stack from real imports, versions from package files, paths from directory structure. Generates .tasuki/ with 9 configured agents, 3 hooks, verified project facts, and an initialized knowledge graph. Takes about 10 seconds.
Yes, for Claude Code. Stages 1–9 run automatically via Agent() sub-agent calls. It stops twice for your input: after the Planner shows you the plan and before Frontend starts building. Everything else is automatic. On Cursor and other tools, the pipeline is structured role-switching — the AI follows instructions in order, but you guide transitions between stages.
That's fine — the QA agent writes the tests first for new features. The tdd-guard hook only blocks edits to implementation files when no corresponding test file exists — it won't break your existing codebase.
No. Tasuki is a CLI tool that runs entirely locally — it generates config files. Your code goes wherever your existing AI tool sends it, same as before. Tasuki adds zero new data flows.
13 profiles auto-detected: FastAPI, Django, Flask, Next.js, SvelteKit, Nuxt, Express, NestJS, Rails, Gin, Spring Boot, Laravel, and Generic fallback. If your stack isn't listed, Generic still configures all 9 agents — it just won't have stack-specific migration patterns.

One command.
Nine engineers.
Zero cold starts.

Free, open source, runs locally. No account needed.

npm install -g tasuki
click to copy
View on GitHub Read the docs