Kieran Klaasen on Agentic Workflows

🧠 Free Recall ❓ Quiz 🔍 Cues 🔮 Simulation 🥷 ShadowBox 📐 Encode Cards

Kieran Klaassen on Agentic Workflows
A distillation of principles and practices for working effectively with AI agents, based on Kieran Klaassen's writings on building Cora.
Core Philosophy
The goal of working with LLMs isn't to automate thinking; it's to clear space for deeper thinking.
When you match your workflow to the shape of the problem, you move faster—in increments of hours rather than days—get unstuck more easily, and ship better work. The only real blockers are human factors: fatigue, distraction, or lack of inspiration.
Universal Meta-Lessons
1. Make Your AI Smarter With Every Feature
The system should compound—each interaction should make future interactions better. Don't just solve the immediate problem; capture the learning so you never make the same mistake twice.
Implementation: After solving a problem, update your agents' knowledge base. Add to checklists, save patterns to documentation files, create specialized agents that encode lessons learned.
2. Plan Before You Execute
"I didn't start by coding. I created a research agent to plan instead."
Planning saves time by preventing you from building the wrong thing entirely. What seems like a quick feature often reveals hidden complexity when properly researched.
3. Parallel Research Operations
When planning with AI, you're running parallel research operations—each one a specialized agent gathering different kinds of knowledge. Then you work together:
Agents bring findings
You make decisions
Together you combine and distill everything into one coherent plan
Key insight: It's much faster for five agents to research in parallel than for a human to plan step by step. Your contribution is taste, judgment, and context about what matters.
4. Use Multiple Model Providers
Don't rely on a single AI provider. Use Anthropic, Google, and OpenAI based on what you're trying to do. Each model frames solutions differently:
ChatGPT might organize by implementation difficulty
Claude might focus on performance
Gemini might highlight what could break existing systems
This diversity helps you see blind spots and synthesize better solutions.
5. Set Goals and Define Rules
You provide the strategic direction and constraints. The AI handles execution within those boundaries. This division of labor is what makes the partnership productive.
6. Match Workflow to Problem Shape
There's no one-size-fits-all approach. Different problems require different workflows:
Clear direction, low stakes → Flow state execution
Ambiguous, exploratory → Research and discovery
Multiple independent tasks → Parallel progress
The key is recognizing which type of problem you're facing.
Three Core Workflow Patterns
Pattern 1: Flow State (Everyday Coding)
When to use:
You know exactly what "done" looks like
You're working on a single, focused task
You need to build efficiently without breaking flow
Stakes are low and direction is clear
How it works:
You are the thinker, AI is the executor
You drive all decisions; AI handles mechanical aspects
You maintain complete control of architecture and design
AI is your hands, not your brain
Tools: Windsurf, Cursor with thinking models (Claude Sonnet 4, Gemini 2.5 Pro)
Key advantage: Speed without sacrificing quality. You speak your intentions; AI translates to code. Like pair programming with a partner who never gets tired.
Mental model: This is inside-out work. You know both the destination and the route. You're delegating the mechanical act of translating decisions into implementation.
Pattern 2: Research & Discovery (Big-Picture Thinking)
When to use:
You're not sure what "done" looks like yet
Components are tightly interwoven
You need to think and explore before you build
Facing a blank canvas or complex architecture
How it works:
Embrace AI as a true thought partner
Start with an open mind
Deliberately avoid pushing too hard in any direction
Goal is to be surprised—discover approaches you wouldn't have considered
Tools: ChatGPT with o3, RepoPrompt, Claude Code agentic search, multiple models in parallel
Process:
Start wide with ambiguous prompts
Let models surprise you with different approaches
Ask increasingly specific questions as you explore
Compare responses across models
Synthesize collective output into coherent plan
Gradually refine and narrow until you have something precise and actionable
Key advantage: Find and understand what you're trying to build before you know how to build it. Define the problem space itself.
Mental model: This is outside-in work. You're discovering both destination and route. Treat responses as rough drafts to combine and refine.
Pattern 3: Parallel Progress (The CTO Method)
When to use:
Multiple components that are not dependent on each other
Each component has clear boundaries and specifications
You've already done architectural thinking up front
You need to coordinate multiple streams of work
How it works:
Break day into discrete tasks
Create detailed specifications for each
Delegate to separate AI agents working simultaneously
Rotate through them, reviewing progress and providing feedback
Tools: Devin, Claude Code with git worktrees, OpenAI's Codex, Cursor Background Agents
Skills required:
Product manager abilities: Breaking down complex features into clear, actionable specifications with well-defined boundaries
Tech lead skills: Reviewing code efficiently, spotting architectural issues quickly, providing clear technical direction
Key advantage: 5-10x productivity multiplier. What might take a week sequentially can compress into a day of parallel work.
Current challenge: Tools and brains aren't fully optimized for this workflow yet. Cognitive load is substantial, but productivity ceiling is dramatically higher.
Mental model: Like a CTO overseeing several engineering teams, each working on different features simultaneously.
Eight Planning Strategies
Strategy 1: Reproduce and Document
What it does: Attempts to reproduce bugs or issues before planning fixes
When to use: Bug fixes, especially Fidelity One and Two issues
Agent's job: Create a step-by-step reproduction guide
Prompt: "Reproduce this bug, don't fix it, just gather all the logs and info you need."
Why it compounds: Update your review agents with new checklist items based on bugs found. "We forgot to retry once. The system won't let us forget again."
Strategy 2: Ground in Best Practices
What it does: Searches the web for how others solved similar problems
When to use: All fidelities, especially unfamiliar patterns
Agent's job: Find and summarize relevant blog posts, documentation, and solutions
Agent name: @agent-best-practices-researcher
Applications: Technical architecture, copywriting patterns, pricing research, upgrade paths, and more
Why it compounds: Save key findings to docs/*.md files. Next time similar questions arise, agents check these documents first before searching the web. Knowledge base constantly grows.
Strategy 3: Ground in Your Codebase
What it does: Finds similar existing patterns in your code
When to use: Anything that might duplicate existing functionality
Agent's job: Search through existing code for related implementations
Why it matters: Prevents building second, incompatible systems. If AI doesn't ground itself in your codebase, it often thinks it needs to create solutions from scratch.
Why it compounds: Create specialist agents (like @event-tracking-expert) that distill everything about specific domains. When planning features in that domain, the specialist runs automatically.
Strategy 4: Ground in Your Libraries
What it does: Reads source code of installed packages and gems
When to use: Fast-moving or poorly documented libraries
Agent's job: Analyze source code to understand what's possible, including undocumented features
Why it compounds: Every time you update a dependency, the knowledge auto-updates. You're never working with stale information.
Strategy 5: Study Git History
What it does: Analyzes commit history to understand intent
When to use: Refactors, continuing work, understanding "why"
Agent's job: Research past decisions and their context
Why it matters: Prevents reintroducing bugs someone else already debugged. Five minutes of git search can save hours of rediscovering known issues.
Why it compounds: Institutional memory gets preserved and searchable. New team members inherit reasoning behind past decisions.
Strategy 6: Vibe Prototype for Clarity
What it does: Rapid prototyping in separate environment to clarify requirements
When to use: Fidelity Three, UX uncertainty, exploratory work
Agent's job: Quickly build throwaway versions you can interact with
Prompt: "Create a working prototype, in the style of a mockup using React and Next, grayscale of XYZ"
Process: Build multiple prototypes quickly, interact with them, gather user feedback, delete prototypes, keep the insights.
Why it compounds: Vibe coding turns uncertainty into concrete specifications. You're not guessing what users want—you're showing them options and documenting their reactions.
Strategy 7: Synthesize with Options
What it does: Combines all research into one plan showing multiple approaches with tradeoffs
When to use: End of research phase, before implementation
Agent's job: Present 2-3 solution paths with honest pros and cons
Format for each option:
Implementation complexity
Performance impact
Maintenance burden
Which existing patterns it matches
Why it compounds: Your choice reveals preferences. When you pick an option and note why, that preference gets codified. Next time there's a similar decision, the system knows how to weight factors.
Strategy 8: Review with Style Agents
What it does: Runs completed plan through specialized reviewers that check for your preferences
When to use: Final planning step, before implementation
Agent's job: Catch misalignments with your coding style and architecture preferences
Example agents:
Simplification agent: Flags over-engineering
Security agent: Checks for common vulnerabilities
Style agent: Enforces your personal preferences
Critical insight: "Most agent architectures add a reviewer subagent to catch mistakes. You pay the cost twice: once to do the work, again to check it. [Better to] load domain expertise exactly when the agent needs it—during execution, not after. Real-time guidance, zero review overhead."
Why it compounds: These agents accumulate your taste over time. Every time you indicate "I don't like this" or "Good catch," the system gets smarter.
Fidelity Levels (Problem Complexity)
Fidelity One: Quick fixes
One-line changes
Obvious bugs
Copy updates
Fidelity Two: Medium features
Features spanning multiple files
Clear scope but non-obvious implementation
Example: Adding a filter option
Fidelity Three: Major features
Don't even know what you're building yet
Requires architectural thinking
Multiple tightly coupled components

Key Principles for Execution
Division of Labor
You provide:
Taste
Judgment
Context about what matters
Architectural decisions
Strategic direction
Quality bar
AI provides:
Mechanical implementation
Parallel research capacity
Pattern recognition across codebases
Speed of execution
Tireless iteration

The Flow State Principle
"The AI editor doesn't break my concentration; it reduces the friction between my intention and implementation."
When in flow:
Stay focused on the creative/strategic work
Delegate mechanical translation to AI
Maintain complete control of important decisions
Use AI to eliminate context-switching cost
The Discovery Principle
"I start with an open mind and deliberately avoid pushing too hard in any direction. The goal is to be surprised."
When exploring:
Give AI loose reins initially
Let models surprise you with approaches you hadn't considered
Use ambiguity as a feature, not a bug
Gradually refine as the solution takes shape
The Parallel Progress Principle
"Traditional software development has always been limited by sequential processes. With AI agents, we can break this pattern."
When coordinating:
Break work into independent streams
Provide clear specifications and boundaries
Rotate through streams reviewing and directing
Accept higher cognitive load for dramatically higher ceiling
Critical Success Factors
1. Continuous Knowledge Capture
Every interaction should improve the system:
Update agent checklists after finding bugs
Save useful patterns to documentation
Create specialized agents that encode learnings
Build institutional memory
2. Appropriate Tool Selection
Match the tool to the task:
Don't use research workflows for clear implementation
Don't use flow-state tools for exploratory work
Don't force parallel progress on tightly coupled work
3. Clear Specifications
Especially for parallel work:
Well-defined boundaries
Clear success criteria
Explicit constraints and preferences
Documented architectural decisions
4. Review and Reflection
Compare final implementation to original plan
Identify where and why you diverged
Capture learnings in reusable form
Update agents based on real experience
5. Embrace Experimentation
"The landscape is evolving rapidly, and the best approach is to keep experimenting, adapting, and refining how we collaborate with these powerful tools."
Don't look for one perfect workflow
Try new patterns and tools
Fail fast and learn
Share and iterate
Common Pitfalls to Avoid
1. Searching for Silver Bullets
"I spent three hours on X last week watching prompt gurus peddle their latest silver bullets... Meanwhile, I shipped five features."
There is no one magic prompt or perfect tool. Different problems need different approaches.
2. Paying the Cost Twice
Loading domain expertise during execution, not after. Don't build then review when you can guide during building.
3. Letting AI Make Architectural Decisions
In flow-state work, you're the architect. AI is your hands, not your brain. Don't abdicate important decisions.
4. Starting Too Specific in Discovery
When researching, start with ambiguous prompts. Let the models show you directions you hadn't considered. Narrow gradually.
5. Under-Scoping for Parallel Work
Parallel progress requires clear boundaries and specifications. Without them, you create chaos, not productivity.
6. Not Capturing Learnings
One-off solutions don't compound. Always ask: "How do I make sure we never forget this lesson?"
The Future State
"We're in the early days of figuring out how to manage multiple AI development streams efficiently. The cognitive load is substantial, but the productivity ceiling is dramatically higher than with any other approach."
What's emerging:
5-10x productivity multipliers for single developers
New tools optimized for parallel AI workflows
Better patterns for managing cognitive load
Evolution beyond traditional sequential development
The blockers are increasingly human factors:
Fatigue
Distraction
Lack of inspiration
Context-switching overhead
As tools improve and practices mature, these human factors become the new frontier for productivity gains.
Conclusion: Creating Space for Human Creativity
"The goal of working with LLMs isn't to automate thinking; it's to clear space for deeper thinking."
Success metrics:
Moving faster (hours instead of days)
Getting unstuck more easily
Shipping better work
Focusing on what requires actual thought
The contradiction isn't a bug, it's the point: Use AI to handle mechanical tasks so you can focus on what matters. Clear away the noise to hear the signal.

Unstarred

Dunk (exclude from study)

Kieran Klaasen on Agentic Workflows

Review Questions

Todos

Sensemaker