AI-Assisted Code Generation Workflow

Purpose

This recipe establishes a structured workflow for building MVP features using AI coding tools — Claude Code, Cursor, Bolt.new, and Replit Agent. The output is a working, human-reviewed codebase built through iterative AI-assisted development: spec first, generate, test, refine. [src1]

Prerequisites

• Product requirements or feature spec — written user stories or feature descriptions
• Project scaffold — existing codebase from Coded MVP Architecture Templates
• AI coding tool installed — Claude Code, Cursor, or browser tool account
• Version control — Git repository initialized with initial commit
• Test framework — Jest, Vitest, or pytest installed

Constraints

• AI-generated code requires human review before deployment — treat AI output as a first draft. [src1]
• Context window limits affect quality — provide focused, relevant context rather than entire codebases. [src5]
• Bolt.new and Replit Agent generate opinionated code that may not match existing architecture. [src3]
• AI tools hallucinate API signatures — always verify against official documentation. [src6]
• Token costs scale with iteration — a typical MVP sprint consumes $5-30 in API costs.

Tool Selection Decision

Which tool?
├── Developer with existing codebase AND terminal workflow
│   └── PATH A: Claude Code — agentic, reads full codebase, runs tests
├── Developer who prefers IDE AND visual editing
│   └── PATH B: Cursor — inline edits, chat, agent mode, multi-file
├── Non-technical founder AND simple app
│   └── PATH C: Bolt.new — browser-based, full-stack from prompt
└── Semi-technical AND needs full IDE in browser
    └── PATH D: Replit Agent — browser IDE, deployment built in

Execution Flow

Step 1: Write a Spec Before Prompting

Duration: 15-30 minutes · Tool: Text editor

Write a structured specification before touching any AI tool. A clear spec produces better AI output than clever prompting. Include user stories, acceptance criteria, technical constraints, and file scope. [src7]

Verify: Spec covers happy path, edge cases, and error states. · If failed: If the spec is vague, the AI output will be vague. Add concrete examples.

Step 2: Set Up Project Context

Duration: 5-10 minutes · Tool: AI tool configuration

Path A (Claude Code): Create a CLAUDE.md file at project root with tech stack, architecture rules, testing conventions, and exclusion rules. [src5]

Path B (Cursor): Create a .cursorrules file at project root with framework, style, and pattern conventions. [src2]

Path C (Bolt.new): Write a comprehensive initial prompt with feature list, tech requirements, and priority order.

Verify: AI tool acknowledges context and references project structure. · If failed: Ensure config files are in the project root.

Step 3: Generate Code Iteratively

Duration: 1-4 hours · Tool: Selected AI tool

Follow the Plan-Generate-Test-Refine loop per feature. Be specific in prompts: name target files, frameworks, data sources, and error handling. After each AI response, read the code, test it, and commit working states. [src1] [src4]

Verify: Feature works per acceptance criteria. Tests pass. · If failed: Share exact error messages with AI. Break the request into smaller pieces.

Step 4: Review and Harden

Duration: 30-60 minutes · Tool: Code editor + testing tools

Run full test suite, TypeScript compilation, linting, and security audit. Review AI-generated code for hardcoded values, missing error handling, and security vulnerabilities. Prompt the AI to write tests for its generated code.

Verify: All tests pass. TypeScript compiles. No lint errors. No critical vulnerabilities. · If failed: Fix issues iteratively with AI tool context.

Step 5: Optimize and Deploy

Duration: 15-30 minutes · Tool: CLI + hosting platform

Build production version, check bundle size, deploy to staging, run Lighthouse audit. Use AI to fix performance issues with specific metric data.

Verify: Production build succeeds. Lighthouse Performance > 80. Staging works. · If failed: Check build logs for errors. Verify environment variables in hosting platform.

Output Schema

{
  "output_type": "ai_generated_codebase",
  "format": "code repository + deployed URL",
  "columns": [
    {"name": "repository_url", "type": "string", "description": "Git repository with code", "required": true},
    {"name": "staging_url", "type": "string", "description": "Deployed staging environment", "required": true},
    {"name": "features_implemented", "type": "string", "description": "Features built with AI", "required": true},
    {"name": "test_coverage", "type": "number", "description": "Code coverage percentage", "required": false},
    {"name": "ai_tool_used", "type": "string", "description": "Primary AI tool used", "required": true},
    {"name": "total_iterations", "type": "number", "description": "Generate-test-refine cycles", "required": false}
  ],
  "expected_row_count": "1",
  "sort_order": "N/A",
  "deduplication_key": "repository_url"
}

Quality Benchmarks

If below minimum: Improve prompt specificity. Provide more context. Consider switching tools based on task type.

Error Handling

Cost Breakdown

Anti-Patterns

Wrong: Prompting with vague descriptions

"Build me a dashboard" produces generic code needing extensive refactoring. [src1]

Correct: Provide specific, constrained prompts

Include target files, framework, component patterns, data sources, and error handling requirements.

Wrong: Accepting AI output without reading it

Leads to inconsistent styles, security vulnerabilities, and compounding technical debt. [src5]

Correct: Review every diff before accepting

Read generated code like a pull request. Check imports, error handling, naming, and architecture alignment.

Wrong: Having AI write the entire app in one prompt

Single-prompt generation produces fragile, hard-to-extend code. [src3]

Correct: Build incrementally, one feature at a time

Scaffold first, add features one by one, commit between features for maintainable, revertible code.

When This Matters

Use this recipe when a developer or technical founder needs a structured methodology for building features with AI coding tools. Requires an existing project scaffold. This recipe covers the workflow and prompting methodology — not specific features to build or tech stack selection.