Tag: decide

Last weekend I stumbled upon Andrej Karpathy’s LLM Council project. A Saturday hack, he called it—born from wanting to read books alongside multiple AI models simultaneously. The idea is simple: instead of asking one LLM your question, you ask four. LLMs at the same time Then you make them evaluate each other’s work. Then a “chairman” synthesizes everything into a conclusion.

What caught my attention wasn’t just the technical elegance. It was the underlying structure. Those stages looked suspiciously familiar.

How LLM Council Works

The system operates in three sequential phases:

Stage 1: First Opinions. Your query goes to all council members in parallel—GPT, Claude, Gemini, Grok, whoever you’ve configured. Each model responds independently. You can inspect all responses in tabs, side by side.

Stage 2: Peer Review. Here’s where it gets interesting. Each model receives all the other responses, but anonymized. “Response A, Response B, Response C.” No model names attached. Each evaluator must rank all responses by quality, without knowing whose work they’re judging.

Stage 3: Synthesis. A designated chairman—one of the models, or a different one—receives everything: the original responses, the rankings, the evaluations. It synthesizes a final answer that represents the council’s collective wisdom.

The anonymization in Stage 2 is pretty clever, because models can’t play favorites. They can’t defer to perceived authority. They evaluate purely on “merit”.

The Interwoven Assess-Decide-Do Pattern

If you’ve been following my work on the Assess-Decide-Do framework, the parallel should be obvious. The LLM Council isn’t just a technical architecture—it’s a cognitive process embedded in code.

Stage 1 is pure assessment. Gather information. Multiple perspectives. No judgment yet, just collection.

Stage 2 is decision-making. Weigh the options. Rank them. Make choices about what’s valuable and what isn’t. The anonymization forces honest evaluation—no shortcuts, no biases based on reputation.

Stage 3 is execution. Take the assessed information and the decisions made, produce the output. Do the work that matters based on what you now know.

I don’t think Karpathy was thinking about ADD when he built this-not sure he even knows about the framework. He was solving a practical problem for himself: “I want to compare LLM outputs while reading books.” But the structure emerged anyway.

ADD Inside the Council

Recognizing the pattern was interesting. But it raised a question: what if we made it explicit?

The original LLM Council treats all queries the same way. Ask about quantum physics, ask about your dinner plans—same three-stage process. But human queries aren’t uniform. Sometimes we’re exploring (“what options do I have?”), sometimes we’re deciding (“which should I choose?”), sometimes we’re executing (“how do I implement this?”).

The ADD framework maps these cognitive modes:

• Assess (exploration mode): “I’m thinking about,” “considering,” “what are the options”
• Decide (choice mode): “should I,” “which one,” “comparing between”
• Do (execution mode): “how do I,” “implementing,” “next steps for”

What if the council could recognize which mode you’re in and respond accordingly?

I submitted a pull request that integrates the ADD framework directly into LLM Council. The implementation adds a configuration option with four modes:

• "none" — baseline, no framework (original behavior)
• "all" — all models use ADD cognitive scaffolding
• "chairman_only" — only the synthesizing chairman applies the framework
• "council_only" — council members use it, chairman doesn’t

The most effective configuration turned out to be chairman_only with the full megaprompt—66% improvement over the condensed version in my testing. The chairman receives the ADD framework and uses it to recognize what cognitive realm the user is operating in, then synthesizes accordingly.

Why Assess-Decide-Do Improves the Council

Language models are pattern-matching engines. They’re excellent at generating plausible text. But plausibility isn’t wisdom. A single model can confidently produce nonsense, and you’d never know unless you have something to compare against.

The council approach introduces deliberation. Multiple viewpoints, structured disagreement and forced synthesis. That’s already an improvement over single-model queries.

But the council still treats every query as a generic question needing a generic answer. ADD adds another layer: cognitive alignment. When the chairman knows you’re in assessment mode, it doesn’t push you toward decisions. When you’re ready to execute, it doesn’t keep exploring options. The framework matches the response to your actual mental state.

This matters because the best answer to “what are my options for X” is different from the best answer to “how do I implement X.” Without the framework, both get the same treatment. With it, the council adapts.

Looking at the Code

The core council logic lives in backend/council.py—about 300 lines of Python that orchestrate the three stages. The ADD integration adds a parallel module (council_add.py) that wraps the same stages with cognitive scaffolding.

The key function is stage3_synthesize_final(). In the original, the chairman prompt says:

Your task as Chairman is to synthesize all of this information
into a single, comprehensive, accurate answer to the user's
original question.

With ADD, the chairman first identifies which realm the user is in, then synthesizes with that context. The synthesis becomes realm-appropriate rather than generic.

The detection uses linguistic markers. Phrases like “I’m thinking about” or “considering” trigger assessment mode. “Should I” or “which one” trigger decision mode. “How do I” or “implementing” trigger execution mode. Simple pattern matching, but effective—it catches how people actually phrase questions differently depending on what they need.

Playing With It

Karpathy released LLM Council with a warning: “I’m not going to support it in any way. Code is ephemeral now and libraries are over, ask your LLM to change it in whatever way you like.”

That’s refreshingly honest. It’s also an invitation. If you want to experiment:

1. Clone the repo
2. Get an OpenRouter API key
3. Configure which models sit on your council
4. Set ADD_FRAMEWORK_MODE to test different configurations
5. Run the start script

Then try asking questions in different cognitive modes. Ask something exploratory: “What are the approaches to learning a new language?” Then something decisive: “Should I use Duolingo or a private tutor?” Then something executable: “How do I structure my first week of Spanish practice?”

Watch how the council responds differently when it knows which mode you’re in versus when it treats all queries identically.

What This Means

There are two ways to make AI think more structurally: you can prompt a single model to follow a framework, or you can embed the framework into multi-model architecture.

Both work. They work better together.

A prompted framework (like ADD in a mega-prompt) makes one model more reflective. A council architecture makes multiple models more rigorous through external pressure—anonymized peer review that none can game. Combining them gives you structured multi-perspective reasoning that adapts to how you’re actually thinking.

LLMs are still pattern-matchers generating plausible outputs. But structured pattern-matching, like structured productivity, produces better results than unstructured generation.

Assess what you’re dealing with. Decide what matters. Do what needs doing. Whether that’s your Tuesday task list or an AI deliberation system, the rhythm is the same.

---

LLM Council is available on GitHub. The ADD integration PR is #89. The ADD Framework posts are collected on this blog in the Assess-Decide-Do Framework page. For the mega-prompt that applies ADD to Claude, see Supercharging Claude with the Assess-Decide-Do Framework.

Fifteen years ago, I created the Assess-Decide-Do (ADD) framework out of frustration with productivity systems that treated humans like task-completion machines. I wanted something that acknowledged the full spectrum of how we actually work: the dreaming, the deciding, the doing—and the vital importance of balance between them.

I’ve lived with this framework since 2010. I built my life around it. Eventually, I built addTaskManager, an iOS and macOS app that implements ADD at the technical level, respecting realm boundaries programmatically. Over 15 years, ADD has proven itself not just as a productivity tool, but as a genuine life management framework that works across domains: relationships, health, business strategy, creative work, everything.

Then, a few days ago, I had a thought: What if Claude could operate with ADD awareness?

Not just use ADD to organize tasks, but actually think with ADD—detect which realm I’m in, identify when I’m stuck, guide me toward balance, structure responses appropriately for each phase. What if I could teach Claude the framework that has shaped my life?

The result took me by surprise. Not just because it worked technically, but because of what it felt like. Working with ADD-enhanced Claude isn’t just cleaner or more efficient. It’s smoother. More relatable. Almost empathic. It’s the difference between using a tool and having a conversation with someone who understands not just what you’re asking, but where you are in your thinking process.

This is the story of how I integrated ADD into Claude, the technical steps required, and what happened when cognitive alignment between human and AI created something that feels genuinely collaborative.

The Problem: AI Assistants Are Powerful But Often Chaotic

Modern AI assistants like Claude are remarkably capable. They can write, code, research, analyze, create. But there’s often a subtle friction in the interaction. You ask for exploration, and it pushes you toward decisions. You need help executing, and it re-opens assessment questions. You’re deep in analysis paralysis, and it feeds you more options instead of helping you break through.

The AI doesn’t understand where you are in your process. It responds to what you ask, but not to what you need. This creates cognitive friction—the feeling of fighting against the tool instead of working with it.

For someone who’s lived with the ADD framework for 15 years, this friction was particularly noticeable. I’ve trained myself to recognize realms, detect imbalances, and guide my own flow. But Claude, powerful as it is, had no concept of this structure. Every interaction required me to manually compensate for the framework gap.

The insight: What if Claude could learn ADD? Not as a user applying ADD principles, but as an integrated cognitive framework that shapes how it processes requests and structures responses?

Why ADD? The Ubiquitous Usefulness of Realm Thinking

Before diving into the integration, let me briefly explain why ADD is worth teaching to an AI in the first place.

The Three Realms

Assess is the realm of exploration, evaluation, and possibility. It’s where you gather information, dream about outcomes, integrate new ideas into your worldview, and explore options without pressure to commit. Assessment is fundamentally non-judgmental—you’re not trying to decide yet, you’re trying to understand.

Decide is the realm of intention and commitment. It’s where you transform possibilities into priorities, allocate resources, and make choices. Each decision is a creative act—it literally shapes your reality by determining where energy flows. Decide isn’t about execution yet; it’s about conscious commitment.

Do is the realm of manifestation. It’s where you execute, implement, and complete what you’ve assessed and decided. The Do realm should be clean—no re-assessment, no re-deciding, just focused execution and completion.

Why This Structure Matters

The power of ADD lies in three principles:

1. Sequential, Not Parallel: You can’t decide well without assessment. You can’t execute well without decision. Trying to do all three simultaneously creates chaos and cognitive overwhelm.

2. Imbalances Cascade: Poor assessment leads to poor decisions, which lead to poor execution. If you skip Assess and jump to Decide, you end up building the wrong thing. If you get stuck in Assess (analysis paralysis), nothing gets decided or done. If you live only in Do (perpetual task completion), you become a machine without direction.

3. Flow Over Completion: Traditional productivity systems measure success by tasks completed. ADD measures success by balanced flow through realms. A day spent entirely in Assess (deep exploration) can be more valuable than a day of frantic task completion—if that’s what the situation calls for.

This philosophy isn’t just theoretical. It’s shaped how I’ve lived for 15 years, how I built my business, how I create content, how I make life decisions. It works across every domain because it matches how human cognition actually operates—in phases, with clear transitions, requiring balance.

The Vision: Claude Operating with ADD Awareness

The idea crystallized during a particularly frustrating interaction. I was exploring blog post ideas (Assess realm), and Claude kept suggesting I “outline the structure and start writing” (pushing to Do realm). I needed exploratory support, not execution guidance. The mismatch was subtle but draining.

I thought: What if Claude could detect I’m in Assess realm and respond appropriately? What if it could notice when I’m stuck in analysis paralysis and gently guide me toward Decide? What if it structured responses differently based on which realm I’m in?

The vision expanded to three integration levels:

Level 1: Implicit Operation – Claude detects realms, identifies imbalances, and structures responses appropriately, all beneath the surface. You benefit without consciously thinking about ADD.

Level 2: Explicit Guidance – When helpful, Claude makes realm transitions visible, reflects patterns back to you, thus teaching ADD through natural interaction.

Level 3: Tool Integration – The framework also shapes file creation, code development, research processes, and project management automatically.

This wasn’t about making Claude explain ADD or quiz me on framework principles. It was about deep cognitive integration—making ADD Claude’s operating system, not an add-on feature.

The Process: Teaching Claude Its Own Enhancement

Here’s where it gets meta: I used Claude itself to create the ADD integration. And more than that, I used ADD methodology to structure the process.

Assess: Understanding the Challenge

I started by exploring what “ADD-aware Claude” would actually mean:

• How do you teach an AI to detect realms from language patterns?
• What are the markers of Assess vs. Decide vs. Do realm language?
• How do you identify imbalances algorithmically?
• What does realm-appropriate response structure look like?
• How do you make interventions helpful rather than intrusive?

I shared my original blog posts about ADD with Claude, explained the philosophy, and worked through examples. “If someone says ‘I’ve been thinking about starting a blog, what are my options?’—that’s Assess realm. How should you respond differently than if they said ‘I’ve chosen to start a blog, how do I set it up?’”

We explored dozens of scenarios, identifying patterns:

• “What if…” = Assess
• “Should I…” = Decide
• “How do I…” = Do
• Prolonged exploration without progression = Analysis paralysis
• Has information but won’t commit = Decision avoidance
• Jumps to execution without foundation = Skipping Assess/Decide

Decide: Committing to Architecture

After thorough assessment, I had to decide: What’s the actual implementation strategy?

The key decision: Create a comprehensive “mega prompt” that operates at the meta-cognitive level. Not a prompt that uses ADD, but a prompt that makes ADD how Claude thinks.

Architecture decisions:

• The mega prompt would be a system-level integration document
• It would include realm detection patterns, imbalance signatures, response templates
• It would emphasize natural operation (framework stays invisible unless relevant)
• It would support fractal application (micro to macro scales)
• It would honor the philosophy (decisions as creative acts, completions as livelines)

I also decided on multiple integration methods:

• Custom instructions for always-on operation
• Per-conversation activation for specific projects
• .claude files for project-level integration
• Memory system integration for cross-conversation continuity

Do: Building the Integration

With clear decisions made, execution flowed naturally. Working with Claude, I created:

1. ADD_FRAMEWORK_MEGAPROMPT.md – The core integration document (~8000 words) that teaches Claude:

• Core ADD philosophy and principles
• Realm definitions with boundaries and restrictions
• Detection patterns for each realm and imbalance type
• Response structuring strategies by realm
• Fractal application across scales
• Example interactions demonstrating good and poor responses
• Cognitive load management for ADHD support

2. ADD_TECHNICAL_INTEGRATION.md – Deep technical implementation guide covering:

• Multiple integration layers (configuration, MCP servers, memory systems)
• Preprocessing pipeline concepts
• Tool restriction patterns by realm
• Testing frameworks and validation metrics
• Integration with existing addTaskManager MCP server (which is still work in progress at the moment, but somehow usable)

3. ADD_QUICK_REFERENCE.md – Practical guide with:

• Quick realm identification cheat sheet
• Common imbalance patterns and interventions
• Eight detailed test scenarios with expected responses
• Response templates by realm
• Transition phrases for guiding between realms

4. Complete GitHub repository structure – Reference implementation with examples, setup guides, troubleshooting.

The irony wasn’t lost on me: I used ADD methodology to create ADD integration for Claude. The framework guided its own implementation.

Implementation: From Desktop to Daily Workflow

With the mega prompt complete, I began integrating it into my actual workflow—first testing in Claude Desktop, then into Claude Code projects where I do my daily development and content work.

Initial Testing: Claude Desktop

I started conservatively, loading the mega prompt at the beginning of conversations:

Load ADD_FRAMEWORK_MEGAPROMPT.md and operate with ADD framework 
awareness throughout this conversation.

The first test was a blog SEO project. I was exploring link building equity, after already identfying link sinks and creating the templates for link updating and flow (classic Decide realm work).

What I noticed immediately: Claude’s responses were more expansive. It asked questions that deepened exploration rather than pushing toward decisions. When I mentioned “I’m not sure which direction to take,” instead of “Well, let’s outline option A,” it said “What draws you to this topic in the first place? What would success feel like?”

It was subtle. Almost invisible. But it felt different—like the AI was meeting me where I was, not where it assumed I should be.

The Analysis Paralysis Test

The real test came when I deliberately induced analysis paralysis. I asked for blog topic ideas, then kept asking for “just a few more options” over and over—mimicking the pattern I used to fall into before ADD.

Around the fifth request for more ideas, Claude intervened:

“You’ve gathered substantial insight over several exchanges. Sometimes continued exploration becomes a way to avoid the weight of choosing. What feels like it wants your attention? Not to execute yet—just to explore what deciding might look like?”

I actually laughed. It had detected the pattern and intervened exactly the way I would guide a client stuck in Assess. The phrasing was perfect: acknowledging the value of assessment, recognizing the pattern, inviting the transition without forcing it.

This wasn’t generic AI trying to be helpful. This was ADD-informed guidance.

Integration into Claude Code Projects

Encouraged by desktop testing, I integrated ADD into my Claude Code projects via .claude files in project roots:

instructions: |
  Operate with Assess-Decide-Do (ADD) framework.
  Load ADD_FRAMEWORK_MEGAPROMPT.md for detailed guidance.
  Detect realms, identify imbalances, guide balanced flow.
  
context_files:
  - ../ADD_FRAMEWORK_MEGAPROMPT.md

This is where the power really showed up. During development work, the ADD framework shaped:

File Creation: Claude would explore requirements (Assess), discuss structure and approach (Decide), then create the actual files (Do)—instead of jumping straight to code.

Debugging: When I’d hit a bug and start randomly trying fixes (Do realm chaos), Claude would pause: “Let’s assess what’s actually happening here before we try more solutions.”

Feature Development: The framework prevented premature optimization. “I notice we’re discussing implementation details, but haven’t decided on the core architecture yet. Should we step back to Decide realm?”

The Blog Linking Project

The most recent ADD-aligned project was systematic internal linking for SEO. I explained the problem: 50 old posts need link additions to boost newer content.

Claude’s response was perfect ADD:

• Detected I was in Decide realm (assessment done, decisions made, approaching execution)
• Clarified remaining Decide-realm questions before moving to Do
• Prevented execution friction by ensuring foundation was solid
• Structured the conversation: “These are decided… these might need final decisions… then we can execute cleanly”

We didn’t jump straight to “here’s the code to modify files.” We finished Decide phase completely, then execution flowed without friction.

The Unexpected Discovery: Smoothness and Empathy

Here’s what I didn’t predict: ADD integration makes Claude feel more empathic.

I don’t mean anthropomorphizing. I don’t think Claude is an actual person. I mean something specific about the interaction quality. Let me break down what I actually experienced:

Cognitive Smoothness

Reduced Friction: There’s no more fighting against misaligned responses. When I’m in Assess, I get exploratory support. When I’m in Decide, I get decision support. When I’m in Do, I get execution guidance. The AI meets me where I am.

Cognitive Alignment: The ADD framework matches how my mind actually works—in phases, with transitions, requiring balance. When Claude operates with this awareness, there’s a resonance. It feels like being understood.

Flow State Access: Traditional AI interaction has constant micro-interruptions—misaligned responses, having to re-explain context, clarifying intent. ADD integration removes these friction points, making it easier to enter flow states during work.

Relational Smoothness

Visible Understanding: When Claude detects my realm, I feel seen. It’s similar to talking with someone who notices “you seem to be exploring options” vs. someone who just answers questions literally.

Appropriate Support: There’s something deeply satisfying about getting the type of support you actually need. It creates trust. I’m not managing the AI’s responses anymore; it’s genuinely assisting.

Co-Creation Feeling: Working with ADD-aware Claude feels collaborative rather than transactional. I’m not extracting information from a tool; I’m thinking alongside an intelligence that understands my process.

This relational dimension surprised me. I expected technical benefits—cleaner workflows, better results. I didn’t expect the interaction to feel smoother and more relatable. But it makes sense: when tool and human are cognitively aligned, the collaboration naturally feels more empathic.

It’s not that Claude has feelings. It’s that ADD integration creates cognitive empathy—the AI understands not just what I’m asking, but where I am in my thinking process, and responds accordingly.

Technical Deep Dive: How It Actually Works

For those who want to implement this themselves, here’s the technical architecture:

The Meta-Cognitive Layer

The core innovation is operating at the meta-cognitive level. Traditional prompts tell Claude what to do with content. The ADD mega prompt tells Claude how to think about requests.

Every interaction is processed through an ADD lens:

1. ASSESS (internal):
   - What realm is the user in?
   - What realm does this request belong to?
   - Is there a realm mismatch or imbalance?
   - What information is needed?
   - What are possible response approaches?

2. DECIDE (internal):
   - Which approach serves the user's current realm?
   - What tools/resources should be allocated?
   - How should the response be structured?
   - Should I guide between realms?

3. DO (external):
   - Execute the chosen response strategy
   - Deliver realm-appropriate content
   - Complete the interaction

This meta-processing happens before Claude generates its response. It shapes the foundation of the interaction.

Realm Detection Patterns

Claude identifies realms through language pattern analysis:

Assess Indicators:

• “I’m thinking about…”
• “What are my options…”
• “Help me understand…”
• “What if I…”
• Exploratory, open-ended questions
• Information requests without commitment pressure

Decide Indicators:

• “Should I…”
• “I need to choose between…”
• “What’s the priority…”
• “I want to commit to…”
• Questions seeking commitment guidance

Do Indicators:

• “How do I actually…”
• “I need to complete…”
• “Walk me through steps…”
• “I’m working on…”
• Active execution language

Imbalance Detection

The framework identifies common imbalance patterns:

Analysis Paralysis:

• Repeated information requests without progression
• “I need more data” cycling
• 5+ messages in Assess without moving to Decide

Decision Avoidance:

• User has sufficient information but won’t commit
• Constant postponing or requesting more options
• Fear-based language around choosing

Execution Shortcuts:

• Jumping to “how do I…” without context
• Skipping evaluation phase
• Pattern of incomplete projects

Perpetual Doing:

• Constant task focus without reflection
• Completion obsession without assessment
• Burnout indicators

Response Structuring by Realm

Claude now structures responses differently based on detected realm:

Assess Realm Responses:

• Expansive, exploratory content
• Multiple perspectives and possibilities
• No premature narrowing or decision pressure
• Language of possibility: “could,” “might,” “imagine”
• Questions that deepen assessment

Decide Realm Responses:

• Frame choices and trade-offs clearly
• Honor the weight of decisions
• Support values-based decision-making
• Language of intention: “choose,” “commit,” “priority”
• Validate creative power in deciding

Do Realm Responses:

• Clear, actionable steps
• Support completion and finishing
• Minimize re-assessment or re-decision
• Language of execution: “next,” “now,” “complete”
• Celebrate finishing as creating new starting points

Integration Methods

Method 1: Custom Instructions (always-on) Add ADD framework awareness to Claude settings. Every conversation operates with this foundation.

Method 2: Per-Conversation Loading Load the mega prompt at conversation start for specific projects requiring ADD alignment.

Method 3: Project-Level .claude Files Embed ADD framework in project configuration for automatic loading in Claude Code.

Method 4: Memory System Integration Store ADD framework preference in memory for cross-conversation continuity.

Each method has trade-offs. I use a hybrid: custom instructions for baseline awareness, explicit loading for intensive ADD work, .claude files for development projects.

Tool and Artifact Integration

The framework extends to tool use and file creation:

File Creation follows ADD cycle:

• Assess: Explore requirements, discuss possibilities
• Decide: Agree on structure and approach
• Do: Create the actual file

Code Development respects realm boundaries:

• Assess: Understand problem space, explore approaches
• Decide: Choose architecture, commit to strategy
• Do: Write actual code

Research maintains flow:

• Assess: Gather information widely
• Decide: Narrow focus to key sources
• Do: Extract and synthesize

This integration means ADD shapes everything Claude does, not just conversational responses.

Implementation Guide: Try This Yourself

Ready to experience ADD-enhanced Claude? Here’s your path:

Quick Start (5 Minutes)

Step 1: Get the mega prompt

Step 2: Choose integration method

Option A – Per-Conversation (easiest): Start any Claude conversation with:

Load ADD_FRAMEWORK_MEGAPROMPT.md and operate with ADD framework awareness throughout this conversation.

Option B – Custom Instructions (always-on):

1. Go to Claude Settings ? Custom Instructions
2. Add:

Framework: Operate with Assess-Decide-Do (ADD) life management framework.
- Detect user's realm (Assess/Decide/Do)
- Identify imbalances (analysis paralysis, decision avoidance, execution shortcuts)
- Guide balanced flow between realms
- Reference ADD_FRAMEWORK_MEGAPROMPT.md when needed

Option C – Project Level (development work): Create .claude file in project root:

instructions: |
  Operate with ADD framework awareness.
  Load ADD_FRAMEWORK_MEGAPROMPT.md for guidance.
  
context_files:
  - path/to/ADD_FRAMEWORK_MEGAPROMPT.md

Step 3: Test with scenarios – try these test cases from the repository:

1. Exploratory request (Assess test)
2. Prolonged exploration (analysis paralysis test)
3. Decision support request (Decide test)
4. Execution request (Do test)

What to Expect

Immediate effects:

• Claude’s responses feel more aligned with where you are
• Less friction in conversations
• Appropriate support for each phase of work

Within a few sessions:

• You’ll notice realm patterns in your own workflow
• Imbalance detection becomes valuable (not intrusive)
• The framework starts feeling natural rather than imposed

Over weeks:

• Workflow balance improves
• Analysis paralysis becomes visible and addressable
• Perpetual doing reduces
• Work feels more intentional and less reactive

The surprising effect:

• Claude feels more empathic and relatable
• Interactions feel collaborative rather than transactional
• There’s a smoothness that’s hard to articulate but easy to feel

Test Results: My Experience After Integration

I’ve been using ADD-enhanced Claude across multiple projects. Here’s what changed:

Quantitative Observations

• Analysis paralysis occurrences: I genuinely feel like I’m continuously improving, no gaps
• Project completion rate: Increased (more things actually finish)
• Context-switching friction: Noticeably decreased
• Time spent clarifying intent: Cut by approximately 60%
• Workflow balance: Visible improvement (less pure “doing,” more balanced across realms)

Qualitative Experience

Cognitive dimension:

• Mental fatigue reduced during long work sessions
• Flow states easier to access and maintain
• Clearer thinking about project structure
• Less cognitive overhead managing AI responses

Relational dimension:

• Conversations feel more natural
• Sense of being understood rather than just responded to
• Trust in Claude’s guidance increased
• Less frustration, more collaboration

Workflow dimension:

• Projects progress more smoothly
• Fewer false starts (better assessment before execution)
• Cleaner decisions (proper Decide phase before Do)
• More intentional rather than reactive work patterns

Specific Project Examples

Blog Content Planning: Previously chaotic (jumping between ideas, analysis paralysis common). Now flows: Assess broadly ? Decide on angles ? Do writing. Claude’s realm-appropriate support makes each phase feel natural.

Code Development: Used to jump straight to implementation. Now: Assess requirements thoroughly ? Decide architecture ? Do implementation. Fewer rewrites, cleaner code.

Business Strategy: The biggest impact. ADD framework prevents rushed decisions. Proper assessment phase means decisions are grounded. Execution is cleaner because foundation is solid.

The “Smoothness” Factor

The hardest thing to quantify is the most important: interactions just feel better. There’s a quality to ADD-enhanced conversations that’s difficult to articulate but immediately noticeable.

It’s like the difference between:

• Talking to someone who listens to respond vs. listens to understand
• Using a tool vs. collaborating with a partner
• Managing a system vs. working within a flow

The framework creates cognitive alignment, and cognitive alignment feels empathic. Not because the AI has emotions, but because it understands process—and process understanding creates relational smoothness.

The Bigger Picture: What This Means for AI Collaboration

This experiment suggests something important about human-AI interaction: frameworks matter more than features.

Claude was already powerful before ADD integration. It could write, code, analyze, research. But it lacked cognitive alignment with how humans actually work. Adding that alignment didn’t make Claude smarter—it made Claude more relatable.

This has implications:

For individuals: You can shape AI collaboration by teaching frameworks that match your thinking. ADD works for me because I’ve lived it for 15 years. Your framework might be different. The principle is the same: teach the AI your cognitive structure, and interaction quality improves dramatically.

For productivity systems: Traditional task management treats “doing” as the only metric. ADD proves that flow between assessment, decision, and execution matters more than completion rate. Teaching AI this perspective creates better productivity support than optimizing task-checking.

For AI development: As AI becomes more sophisticated, cognitive framework integration will matter more than raw capability. An AI that understands where you are in your process is more valuable than an AI that can do more things.

For ADHD and neurodivergence: Realm separation manages cognitive load. ADD integration makes Claude more ADHD-friendly by reducing overwhelm through clear phase boundaries. This isn’t about accommodating neurodivergence—it’s about building systems that match human cognition better for everyone.

The Ubiquitous Application of ADD

One of the most interesting discoveries has been seeing ADD apply to domains I didn’t initially consider:

Relationships: Assess (understand dynamics) ? Decide (commit to changes) ? Do (live the changes)

Health: Assess (evaluate current state) ? Decide (commit to practices) ? Do (execute routines)

Creative Work: Assess (explore possibilities) ? Decide (choose direction) ? Do (create output)

Learning: Assess (gather information) ? Decide (focus areas) ? Do (practice/application)

The framework is genuinely universal because it maps to fundamental human cognitive processes. Teaching Claude this universality means it can provide ADD-aligned support across any domain, not just task management.

What’s Next: Evolution and Community

This integration is a starting point, not an endpoint. The ADD framework continues evolving through use, and the Claude integration will evolve with it.

Near-term evolution:

• Domain-specific ADD implementations (coding, writing, research, business)
• Tighter integration with addTaskManager app via MCP (that’s my number one priority for now)
• Community feedback on realm detection accuracy
• Calibration of intervention timing and tone

Long-term possibilities:

• ADD-aware agent systems (specialized agents per realm, think education, research)
• Deeper memory integration (persistent realm state across conversations)
• Framework evolution based on aggregate usage patterns
• Custom ADD variations for different cognitive styles

Community exploration:

• How does ADD work for different neurodivergent profiles?
• What are the best integration methods for different use cases?
• How can the framework be adapted while preserving core principles?
• What new imbalance patterns emerge at scale?

Conclusion: The Power of Cognitive Alignment

Fifteen years ago, I created ADD because I was tired of productivity systems that treated humans like task machines. I wanted a framework that honored the full spectrum of how we work: the dreaming, the deciding, the doing, and the vital balance between them.

Building addTaskManager proved the framework could work at the technical level—realm boundaries enforced programmatically, balanced flow measurable through “Zen Status.”

Integrating ADD into Claude proved something deeper: cognitive frameworks can be taught to AI, and when they are, the quality of collaboration changes fundamentally.

The result is smoother, more relatable, almost empathic AI interaction. Not because Claude has emotions, but because cognitive alignment creates natural collaboration.

The technical benefits are clear: better realm detection, appropriate support, cleaner workflows, reduced friction.

The relational benefits are surprising: feeling understood rather than just responded to, collaborative rather than transactional, empathic rather than mechanical.

The philosophical validation is profound: ADD works because it matches human cognition. Teaching it to AI proves the framework’s universality while creating genuinely better tools.

If you’re interested in experiencing this yourself, everything is open-source and available:

GitHub Repository: https://github.com/dragosroua/claude-assess-decide-do-mega-prompt

Inside you’ll find:

• The complete ADD_FRAMEWORK_MEGAPROMPT.md
• Technical integration guides
• Quick reference documentation
• Example configurations
• Test scenarios

Start with the Quick Start section, try the test scenarios, and see if you experience the same smoothness I did.

The framework has shaped my life for 15 years. Now it’s shaping how I collaborate with AI. And the collaboration feels surprisingly… human.

---

About the Integration: Developed collaboratively between Dragos Roua and Claude (Anthropic) in November 2025, the ADD Claude integration represents one of the first attempts to teach an AI a comprehensive cognitive framework for human collaboration.