Beginner Guide

Build Your First Product
with Raftkit

Walk through building a task manager using Raftkit's 5-phase workflow. See how structure turns chaotic AI prompting into a predictable, repeatable process.

~30 min read|5 phases|1 shipped product
Want to understand the methodology behind each phase? Read How It Works →

Before You Begin

What you need

  • ✓Claude Code installed and working
  • ✓A terminal
  • ✓Basic coding familiarity

What you DON'T need

  • ✗A pre-written product spec
  • ✗An upfront architecture plan
  • ✗Experience with Raftkit

Install Raftkit

claude plugin install raftkit

That's it. No npm packages, no config files, no setup scripts.

Phase 0 — Init Your Project

Create a new project folder and initialize git, then let Raftkit scan your project and set everything up.

mkdir task-manager && cd task-manager && git init
/raftkit:init
~/task-manager
$ /raftkit:init
  Detecting project type... Fresh project
  No existing stack detected
  ✓ Git workflow configured
  ✓ Commit conventions set up
  ✓ 48 AI skills loaded
  ✓ 23 review agents ready
  ✓ 5-phase workflow active
  Run /raftkit:blueprint to start your first product.

Raftkit scanned your project and set up git conventions. It knows this is a fresh project and will guide you to blueprint first.

Phase 1 — Blueprint Your Task Manager

/raftkit:blueprint task-manager

Blueprint is a single collaborative session with four acts. Think of it as an AI product manager, architect, and designer all working with you at once.

Act 1 — Product Discovery

Raftkit asks you 4-8 questions: Who are the users? What problem does this solve? What's the core feature?

Blueprint — Act 1
Raftkit: Who is the primary user of this task manager?
You: Individual developers who want a simple, fast task tracker
Raftkit: What's the core problem they face with existing solutions?
You: Too complex. They just want tasks, priorities, and due dates.
Raftkit: What makes this different from Todoist or Apple Reminders?
You: Keyboard-first, markdown support, and developer-focused integrations

Act 2 — Tech & Design Discovery

It asks about your tech preferences. Don't have any? That's fine — it'll pick sensible defaults. Example: "Do you have a preferred frontend framework?" → "React with Next.js"

Act 3 — Research & Architecture

Raftkit researches competitors (Todoist, Asana, Things 3), designs your database schema, plans your API, and creates design tokens — all autonomously.

PRD Snippet

## Core Features
1. Task CRUD with markdown body
2. Priority levels (P1-P4)
3. Due dates with smart reminders
4. Keyboard shortcuts for all actions
5. Full-text search across tasks

DB Schema Snippet

tasks
├── id          UUID (PK)
├── title       VARCHAR(255)
├── body        TEXT (markdown)
├── priority    ENUM (P1-P4)
├── due_date    TIMESTAMP
├── status      ENUM
├── user_id     UUID (FK)
└── created_at  TIMESTAMP

Act 4 — Review & Refine

Walk through each section together. Change anything that doesn't feel right. The AI explains its decisions and adjusts based on your feedback.

What got created

  • brainstorms/prd.md — product spec
  • brainstorms/competitive-analysis.md — competitor matrix
  • brainstorms/market-analysis.md — TAM/SAM/SOM
  • brainstorms/decisions.md — decision log
  • architecture/db-schema.md — ERD + indexes
  • architecture/tech-stack.md — technology rationale
  • architecture/system-diagram.md — components + data flow
  • architecture/api-contracts.yaml — OpenAPI spec
  • architecture/design-system.md — tokens + UI specs
  • architecture/sample-data.md — seed records + types
  • architecture/tech-preferences.md — your stack choices
  • architecture/third-party-services.md — integrations
  • constitution.md — quality rules
  • status.md — progress tracking

Key insight: You just created a production-grade spec in one conversation. A human team might spend 2-4 weeks on this.

Phase 2 — Plan the Work

/raftkit:plan

Raftkit reads your blueprint and breaks it into features, then scores each feature using RICE — Reach, Impact, Confidence, and Effort. High-impact, low-effort features go first.

Feature Prioritization
  Features prioritized by RICE score:
  1. User Authentication (RICE: 42)
  2. Task CRUD Operations (RICE: 38)
  3. Due Dates & Priorities (RICE: 35)
  4. Full-Text Search (RICE: 28)
  5. Keyboard Shortcuts (RICE: 24)

Each feature gets broken into micro-tasks — not week-long tickets, but tiny 2-5 minute chunks. Each task has clear acceptance criteria using the EARS format.

tasks/user-auth/task-001.md

Create User model and auth endpoints

EARS Acceptance Criteria

WHEN a user submits valid credentials THE SYSTEM SHALL return a JWT token and 200 status

Key insight: Small tasks = small mistakes. The AI can complete a 3-minute task reliably. A 3-day task? Not so much.

Phase 3 — Build Your Task Manager

/raftkit:build task-manager

Raftkit picks up the first micro-task from your plan and spins up a fresh AI agent to build it. A fresh agent per task means no context bleed between tasks — each one starts clean.

What happens for each task

1
Reads the task file — requirements, acceptance criteria, dependencies
2
Writes tests FIRST — the code doesn’t exist yet, but the tests define what it should do
3
Implements code to make the tests pass
4
Runs verification — actual terminal output captured as evidence
5
Commits if tests pass, or debugs if they don’t

Want to review each task before it commits? Use supervised mode:

/raftkit:build task-manager supervised

Why TDD matters here: When the AI writes tests first, it can't fool itself. The tests are a contract. Either the code meets the contract, or it doesn't. No hand-waving.

Phase 4 — Review the Code

/raftkit:review

Every piece of code gets a quality check. The review runs in two stages: first, does the code actually match the task spec? Then, up to 23 specialized AI reviewers examine it from different angles — security, performance, accessibility, architecture, and more.

Example findings

P1Blocks commit

Missing input sanitization on task title — XSS vulnerability

P2Should fix

Auth middleware not checking token expiry

P3Logged

Consider adding rate limiting to auth endpoint

P1 findings block the commit — the AI has to fix them before moving on. P2 findings should be addressed. P3 findings are logged for later.

Phase 5 — Compound Your Learnings

/raftkit:compound

This is what makes Raftkit different from a one-shot code generator. After building, Raftkit looks at what it learned across all tasks — what patterns kept coming up, what mistakes it made, what conventions your codebase follows.

It writes those patterns into your project's CLAUDE.md file. Next time the AI works on your codebase, it already knows your naming conventions, your error handling patterns, your preferred libraries. The AI gets smarter about YOUR project with every task it completes.

Key insight: Most AI tools start from zero every time. Raftkit accumulates knowledge. Task 50 is built with everything learned from tasks 1-49.

Want to put your development on autopilot?

Once you're comfortable with Build, Review, and Compound individually, chain them all together with a single command. One approval gate, then Raftkit builds every task in your plan — reviewing and compounding as it goes.

/raftkit:auto task-manager

Add supervised to pause after each task for your review before it commits.

Quick Bug Fixes

Don't need the full workflow for a small fix? Skip straight to it.

/raftkit:fix "login button not redirecting after auth"

Raftkit will investigate the bug, write a test that reproduces it, fix it, verify the test passes, and commit — all in one shot.

Command Reference

CommandDescription
/raftkit:initProject onboarding + stack detection
/raftkit:blueprintPRD + architecture + design in one session
/raftkit:planRICE features + micro-task breakdown
/raftkit:buildTDD build loop, one task at a time
/raftkit:reviewTwo-stage quality review
/raftkit:compoundAggregate learnings + evolve docs
/raftkit:autoAuto Pilot: Build + Review + Compound
/raftkit:fixQuick bug fix, skip full workflow
/raftkit:statusProgress dashboard

All commands default to guided mode which explains each step as it happens. Add quick to skip explanations for experienced users.

Tips for Success

Start with guided mode

It explains every methodology (RICE, EARS, TDD) the first time you encounter it.

Review the blueprint carefully

It's the foundation for everything. A good blueprint means better tasks, better code, better product.

Use supervised mode first

On your first build, use supervised mode to see how the AI works before going fully autonomous.

Don't skip compound

The compound phase is how your project gets smarter. It writes patterns into CLAUDE.md for future tasks.

Any command works standalone

You don't have to follow the full workflow. Need a quick review? Just run /raftkit:review.

Quick mode for speed

Once you're comfortable, add "quick" to any command to skip explanations and checkpoints.

Ready to build?

Install Raftkit and start your first blueprint.

claude plugin install raftkit
← Back to homeGitHub