The 4-Phase AI Development Workflow

The methodology that makes AI development actually work.

This workflow represents years of production-tested refinement. The key insight: the DEFINE phase represents 70% of meaningful work and is the primary determinant of project success.

---

Overview

┌─────────────────────────────────────────────────────────────────┐
│                    4-PHASE AI WORKFLOW                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. DEFINE (70%)     2. REFINE         3. MULTIPLY    4. EXPAND │
│  ┌──────────────┐   ┌──────────────┐  ┌──────────┐  ┌─────────┐│
│  │ Voice Notes  │   │ Plan Mode    │  │ Parallel │  │ PR Mgmt ││
│  │ Visual Notes │   │ /clear often │  │ Agents   │  │ Slash   ││
│  │ PRD (WHAT)   │   │ Screenshots  │  │ Cloud    │  │ Commands││
│  │ User Story   │   │ Write Tests  │  │ Async    │  │ Research││
│  └──────────────┘   └──────────────┘  └──────────┘  └─────────┘│
│                                                                  │
│  Success = 70%         Iterate            Scale        Leverage  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

---

Phase 1: DEFINE (The Critical 70%)

"If I am successful in a project, it is almost certain I'm successful because of this phase."

The DEFINE phase determines project success. Invest here before touching any code.

1.1 Voice Recording / Walking Ideation

Capture raw ideas verbally while walking:

• Free-associate ideas without editing
• Don't aim for final conclusions during ideation
• Allow your mind to meander and explore possibilities
• Raw ideas are valid—refinement comes later

Why walking? Physical movement unlocks creative thinking. Record voice memos, then transcribe.

1.2 Visual Documentation

Create annotated screenshots of current state:

┌────────────────────────────────────────┐
│      Before: Current UI State          │
│  ┌──────────────────────────────────┐  │
│  │                                  │  │
│  │   [Screenshot of current app]   │  │
│  │                                  │  │
│  │   ← Pink arrow: "Move this"     │  │
│  │                                  │  │
│  │   ○ Circle: "Remove this"       │  │
│  │                                  │  │
│  └──────────────────────────────────┘  │
│                                        │
│  After: Desired State                  │
│  ┌──────────────────────────────────┐  │
│  │                                  │  │
│  │   [Annotated mockup]            │  │
│  │                                  │  │
│  └──────────────────────────────────┘  │
└────────────────────────────────────────┘

Tools: CleanShot, native screenshot tools, Figma, or simple markup apps.

1.3 Generate PRD (Product Requirements Document)

Combine voice transcript + visual notes + component definitions:

Critical constraint: Focus on WHAT, not HOW.

Element	Description	Example
User capabilities	What should users be able to see/do?	"Users can drag windows freely"
Restrictions	What should users NOT be able to see/do?	"No access to admin settings"
Interactions	How do parts relate to each other?	"Sidebar updates when main panel changes"
Priorities	What's most important?	"Speed is priority #1"
Emotional outcome	What should the user feel?	"I grab the window, I move it, everything listens to me, nothing fights back"

Zero technical implementation details. The PRD tells the story of user experience.

1.4 Example PRD Structure

# Feature: Drag-and-Drop Window Management

## User Story
As a power user, I want to grab any window and move it freely,
so that I feel in complete control of my workspace.

## What Users Can Do
- Drag any window to any position
- Resize windows from any edge
- Snap windows to grid positions

## What Users Cannot Do
- Move windows outside viewport
- Overlap critical system elements

## Interactions
- Dragging one window repositions others
- Releasing a window triggers snap-to-grid

## Emotional Outcome
"Everything listens to me, nothing fights back."

## Priority
Speed > Aesthetics > Features

---

Phase 2: REFINE (Iterative Improvement)

Once you have a solid DEFINE phase, the REFINE phase is about iterating until the implementation is right.

2.1 Context Management (Critical)

The Problem: Context window accumulation degrades model performance.

The Solution: Clear context aggressively.

/clear    # Create fresh chat context

Rule of Thumb: Clear context whenever you finish a discrete task, or when the next task isn't directly related to the previous conversation.

2.2 Plan Mode Workflow

Before implementation, iterate in Plan Mode:

1. Use Shift+Tab to cycle through modes
2. Enter Plan Mode before implementation
3. Plan Mode = conversational, no file writes
4. Iterate on plan until satisfied ("measure 50 times, cut once")
5. Reference PRD and visual assets during planning

┌─────────────────────────────────────────────────────────────────┐
│                      PLAN MODE WORKFLOW                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. Enter Plan Mode (Shift+Tab)                                 │
│  2. Describe what you want (reference PRD)                      │
│  3. Iterate: "Actually, let's also consider..."                 │
│  4. Iterate: "What about edge case X?"                          │
│  5. Iterate: "Show me the file changes"                         │
│  6. When satisfied → Implementation Mode                        │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

2.3 Screenshot Integration

Why it matters: Models cannot see your screen. They infer UI state from code.

Workflow:

1. Use screenshot utility with quick keystroke
2. Annotate screenshots with arrows, highlights, notes
3. Paste directly into terminal with Ctrl+V (or Cmd+V on Mac)
4. Reference specific visual elements: "Do you see the two pink arrows?"

# Example conversation
You: [paste screenshot with annotations]
You: "Do you see the component with the red circle?
      Move it to where the green arrow points."

2.4 Testing Discipline

Reality Check: Models know how to write tests but won't remember to do so unprompted.

Required Reminders:

• Explicitly request test case creation
• Remind to run test cases
• Add testing requirements to CLAUDE.md

# In your CLAUDE.md file:

## Testing Requirements
- Write unit tests for all new functions
- Run tests before marking task complete
- Include edge case tests

Consequence of Neglect:

"If you don't have good tests, three months down the road, you will cry."

2.5 CLAUDE.md for Persistent Instructions

The CLAUDE.md file loads into every conversation. Configure for:

# CLAUDE.md

## Code Style
- Use TypeScript strict mode
- Prefer functional components
- Keep functions under 30 lines

## Testing
- Unit tests required for business logic
- Remind me to run tests

## Communication
- Show file changes before writing
- Explain trade-offs when making decisions

---

Phase 3: MULTIPLY (Parallel Agent Execution)

Use Claude AI web interface (claude.ai) or equivalent platforms to run multiple agents in parallel.

3.1 The Unlock

Feature	Benefit
Parallel execution	Multiple changes simultaneously
Asynchronous operation	Not tied to terminal/machine
Cloud-based	Works from phone, survives shutdown
Exploratory	Kick off 4-5 variants, pick best approach

3.2 Workflow Pattern

┌─────────────────────────────────────────────────────────────────┐
│                    MULTIPLY WORKFLOW                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. Go to claude.ai → Projects                                  │
│  2. Select your project (same codebase as local)                │
│  3. Submit multiple change requests:                            │
│                                                                  │
│     ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐     │
│     │Approach A│  │Approach B│  │Approach C│  │Approach D│     │
│     │(Running) │  │(Running) │  │(Running) │  │(Running) │     │
│     └──────────┘  └──────────┘  └──────────┘  └──────────┘     │
│                                                                  │
│  4. Disconnect - tasks run in cloud                             │
│  5. Review all approaches when complete                         │
│  6. Pick the best direction                                     │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

3.3 Use Cases

• Exploring multiple implementation directions - Not sure which approach is best? Run 4-5 variants
• Parallelizing independent features - Multiple unrelated changes at once
• Batch processing similar changes - Apply same pattern across many files
• Disconnected development - Start on desktop, check results on phone

---

Phase 4: EXPAND (Beyond Code)

4.1 PR Management via Claude Code

# Check open PRs
"Hey, what are the open PRs?"

# Review and merge
"I have two PRs open against this repo. I've verified both.
Approve them, merge them back, and update main."

Result: Complete GitHub workflow without leaving terminal.

4.2 Custom Slash Commands

Create project-specific commands that persist with the repository:

/git-push     # Custom push workflow
/test         # Project-specific test runner
/dev          # Development environment setup
/install      # Installation sequence

Benefits:

• Check into version control
• Available when returning to project weeks later
• Encode project-specific knowledge

CODITECT provides 184+ built-in commands. Create custom ones for your specific workflows.

4.3 File Transformation (Non-Code Operations)

The Revelation: Claude Code works on any local files, not just source code.

Example: JSON Data Enhancement

• Input: Board game history file with short descriptions, broken images
• Process: 45-minute autonomous deep research
• Output: Validated images, extended descriptions, verified external links

Other Demonstrated Uses:

• Audio file conversion
• Image analysis and renaming
• Document research and compilation
• Meeting notes processing
• Video script writing

4.4 The Harness Model

Claude Code operates as an iterative problem solver:

1. Creates internal to-do list
2. Works through items systematically
3. Can run unattended for extended periods
4. Checkpoints progress automatically

---

Key Tactical Patterns

Context Commands

Command	Effect
/clear	Fresh chat context
Shift+Tab	Cycle through modes
/cx	Save session to CODITECT memory
/cxq "topic"	Search past work

Success Factors Summary

Factor	Why It Matters
1. Define Phase Investment	70% of success determined here
2. Context Hygiene	Clear frequently, minimize window size
3. Visual Communication	Screenshots with annotations
4. Testing Discipline	Explicit reminders, persistent config
5. Parallel Execution	Multiply agents for exploration
6. Slash Commands	Encode project knowledge
7. File Transformation	Extend beyond code to any file type

---

CODITECT Integration

CODITECT enhances this workflow with:

Phase	CODITECT Enhancement
DEFINE	/which finds the right agent for your task
REFINE	Background services auto-save context (no manual /cx needed)
MULTIPLY	157 specialized agents for parallel work
EXPAND	all slash commands + 1,152 workflows ready to use

Quick Start with CODITECT

# Phase 1: DEFINE - Find the right agent
/which "build a REST API"

# Phase 2: REFINE - Use specialized agents
/agent senior-architect "Review this API design"

# Phase 3: MULTIPLY - Run parallel agents
Task(subagent_type="Explore", prompt="Find all authentication patterns")
Task(subagent_type="security-specialist", prompt="Audit auth implementation")

# Phase 4: EXPAND - Leverage full platform
/cxq "authentication patterns"  # Search past work
/git-sync --target all          # Sync everything

---

Workflow Diagram

┌─────────────────────────────────────────────────────────────────┐
│                         DEFINE (70%)                            │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐  │
│  │  Voice   │ +  │  Visual  │ +  │Component │ → │   PRD    │  │
│  │  Notes   │    │  Notes   │    │   Docs   │    │(WHAT not │  │
│  │(Walking) │    │(Annotate)│    │          │    │   HOW)   │  │
│  └──────────┘    └──────────┘    └──────────┘    └──────────┘  │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│                          REFINE                                  │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐  │
│  │Plan Mode │ → │Iterate on│ → │Screenshot│ → │  Write   │  │
│  │(Measure  │    │  Plan    │    │  Debug   │    │  Tests   │  │
│  │50 times) │    │          │    │          │    │          │  │
│  └──────────┘    └──────────┘    └──────────┘    └──────────┘  │
│                    ↑                                            │
│              /clear frequently                                  │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│                         MULTIPLY                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              Claude AI Web Interface                     │   │
│  │  ┌────────┐  ┌────────┐  ┌────────┐  ┌────────┐        │   │
│  │  │Agent 1 │  │Agent 2 │  │Agent 3 │  │Agent N │        │   │
│  │  │(Async) │  │(Async) │  │(Async) │  │(Async) │        │   │
│  │  └────────┘  └────────┘  └────────┘  └────────┘        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│                          EXPAND                                  │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐  │
│  │PR Management │  │Slash Commands│  │  File Transformation │  │
│  │via Terminal  │  │(Persistent)  │  │  (Any local files)   │  │
│  └──────────────┘  └──────────────┘  └──────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

---

Summary

The 4-Phase Workflow in One Sentence:

Define what you want (70%), refine with clear context and tests, multiply with parallel agents, expand beyond code to all knowledge work.

Next Steps:

• CODITECT-WELCOME-ABOARD.md - Quick start
• CODITECT-COOKBOOK.md - Ready-to-use recipes
• CODITECT-FULL-CAPABILITIES.md - All 15 domains

---

Last Updated: January 12, 2026 Version: 1.0.0 Framework: CODITECT v2.0.0