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):
- Go to Claude Settings ? Custom Instructions
- 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:
- Exploratory request (Assess test)
- Prolonged exploration (analysis paralysis test)
- Decision support request (Decide test)
- 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.