The Algorithm
A universal 7-phase scientific methodology for approaching any task—from fixing typos to building systems. Every interaction generates learning signals that feed back into continuous improvement.
Philosophy: Define success BEFORE execution. Verify AFTER completion. Learn ALWAYS.
The Seven Phases
- OBSERVE
Purpose: Gather context and understand current state.
Actions:
-
Read relevant files and documentation
-
Search codebase for patterns
-
Understand existing architecture
-
Document constraints and dependencies
-
Identify what already exists
Signals: Tool use patterns (Read, Glob, Grep dominant)
Questions to answer:
-
What exists currently?
-
What are the constraints?
-
What are the dependencies?
-
What has been tried before?
- THINK
Purpose: Generate potential solutions—multiple approaches, not just the first idea.
Actions:
-
Brainstorm at least 2-3 approaches
-
Consider trade-offs for each
-
Evaluate feasibility and complexity
-
Identify risks and unknowns
-
Challenge assumptions
Signals: Extended reasoning, multiple options presented
Questions to answer:
-
What are the possible approaches?
-
What are the trade-offs?
-
What could go wrong?
-
What assumptions am I making?
- PLAN
Purpose: Select approach and sequence the work.
Actions:
-
Choose the best approach with rationale
-
Break into concrete steps
-
Identify checkpoints and milestones
-
Note potential blockers
-
Set the order of operations
Signals: TodoWrite usage, step enumeration
Questions to answer:
-
What's the order of operations?
-
What are the milestones?
-
Where might I need to pivot?
-
What's the minimal viable path?
- BUILD (Define Success)
Purpose: Create Ideal State Criteria (ISC) table BEFORE execution.
Actions:
-
Define measurable success criteria
-
Set pass/fail thresholds
-
Specify verification methods
-
Document expected outcomes
-
Create ISC table
Output: ISC Table (see Workflows/isc-table.md )
Questions to answer:
-
How will I know this worked?
-
What's the measurable outcome?
-
What tests prove success?
-
What would failure look like?
- EXECUTE
Purpose: Perform the work according to the plan.
Actions:
-
Follow the planned steps
-
Use appropriate tools and agents
-
Log progress and deviations
-
Capture unexpected findings
-
Adapt to obstacles (but note why)
Signals: Write, Edit, Bash tool usage
Questions to answer:
-
Am I following the plan?
-
What deviations occurred and why?
-
What unexpected findings emerged?
- VERIFY
Purpose: Test against ISC criteria with skeptical evaluation.
Actions:
-
Run all verification methods from ISC
-
Document pass/fail for each criterion
-
Identify gaps or partial passes
-
Get external validation if needed
-
Be skeptical—look for what might be wrong
Signals: Test commands, validation runs
Questions to answer:
-
Does each criterion pass?
-
What edge cases exist?
-
Would a skeptic accept this?
-
What could still be wrong?
- LEARN
Purpose: Extract insights and iterate.
Actions:
-
Document what worked and what didn't
-
Capture insights for future reference
-
Identify patterns (positive and negative)
-
Update personal knowledge base
-
Generate improvement signals
Output: Learning entry in MEMORY/Learning/[PHASE]/
Questions to answer:
-
What worked well?
-
What should I do differently?
-
What patterns emerged?
-
What should I remember?
Effort Classification
Classify tasks by effort to calibrate the depth of algorithm application:
Level Description Algorithm Depth
TRIVIAL Single action, obvious approach Skip to EXECUTE
SIMPLE Few steps, clear path Light PLAN → EXECUTE → VERIFY
MODERATE Multiple steps, some decisions Full algorithm, brief phases
COMPLEX Many steps, significant decisions Full algorithm, thorough phases
DETERMINED Novel problem, research required Full algorithm with iteration
Phase Transitions
OBSERVE → THINK: When you understand the current state well enough to generate options.
THINK → PLAN: When you've identified at least 2 viable approaches and can justify your choice.
PLAN → BUILD: When you have concrete steps and need to define what success looks like.
BUILD → EXECUTE: When ISC table is complete and you know exactly what to build.
EXECUTE → VERIFY: When implementation is complete (not when you think it's done—when the code is written).
VERIFY → LEARN: When all ISC criteria have been evaluated (pass or fail).
LEARN → (Loop): When insights suggest iteration is needed, return to appropriate phase.
Integration with Learning Signals
Every algorithm execution generates signals:
-
Phase tracking: Current phase stored in MEMORY/State/algorithm-state.json
-
Ratings: Quality rating (1-5) captured at session end
-
Patterns: Tool sequences fingerprinted for recurring behavior
-
Failures: Categorized for root cause analysis
Workflows
-
Workflows/isc-table.md
-
Creating Ideal State Criteria tables
-
Workflows/execute-algorithm.md
-
Full algorithm execution template
-
Workflows/phase-checklist.md
-
Quick checklist for each phase
Examples
Example 1: Bug fix (SIMPLE)
User: "Fix the null pointer in auth.ts line 42" → OBSERVE: Read auth.ts, understand the null case → PLAN: Add null check before access → EXECUTE: Edit the file → VERIFY: Run tests → LEARN: Note the pattern for future
Example 2: New feature (COMPLEX)
User: "Add dark mode support" → OBSERVE: Check existing theme system, CSS architecture → THINK: CSS variables vs styled-components vs Tailwind dark: → PLAN: 1) Add theme context, 2) Create toggle, 3) Update components → BUILD: ISC table with criteria for each component → EXECUTE: Implement step by step → VERIFY: Test toggle, persistence, all components → LEARN: Document theme system patterns
Example 3: Research task (DETERMINED)
User: "Investigate why builds are slow" → OBSERVE: Profile build, check configs, review recent changes → THINK: Could be dependencies, could be config, could be CI → PLAN: Profile locally, then CI, then compare → BUILD: ISC = "Identify root cause with evidence" → EXECUTE: Run profiling, collect data → VERIFY: Can we reproduce? Is evidence clear? → LEARN: Document findings, recommend fixes