When I first integrated my Assess-Decide-Do framework into Claude, I used a 24,000-character megaprompt. It worked remarkably well – and it was my first experiment ever with applying a human cognitive framework to an LLM (potentially the first one ever). A recent update to Claude Code changed something really deep, and added unexpected tools to improve my implementation. Now the same framework runs with 94% less overhead, and with features I couldn’t implement before.
What is ADD?
Assess-Decide-Do is a simple idea: at any moment, you’re in one of three mental states:
- Assess — You’re exploring, gathering information, asking “what if?”
- Decide — You’re choosing, committing, allocating resources
- Do — You’re executing, completing, finishing
These states are sequential. You can’t decide well without assessing first. You can’t execute well without deciding first. And when you skip steps—jumping from idea to execution without thinking it through—things tend to go wrong.
I created this framework 15 years ago to manage my own scattered thinking. It became an iOS app (addTaskManager), and eventually I wondered: could AI understand this framework too?
My Original Approach: One Big MegaPrompt
My first integration was almost blunt—a 24KB megaprompt that explained everything: what each realm means, how to detect which realm someone is in, what language patterns indicate each state, how to recognize when someone is stuck, and how to respond appropriately.
Every conversation loaded the entire framework context. Claude would read 24,000 characters before even responding to “hello.”
Did it work? Yes, surprisingly well. Users reported Claude feeling “weirdly empathic”—it understood whether they were exploring or executing, and responded accordingly. The github repo got 60+ stars, forked 10+ times and the Reddit post became viral.
The problem? Context is precious. Loading 24KB of framework instructions for every exchange meant less room for actual conversation. It was like bringing an encyclopedia to answer what time it is.
Replacing the Monolithic Megaprompt with Skills
In January 2026, Claude Code merged slash commands and skills into a unified system. Two features mattered most:
- Progressive disclosure — Skills load context dynamically, only when needed
- Subagent support — Skills can spawn isolated agents that don’t pollute your main conversation
This enabled things that the ADD integration couldn’t do with the megaprompt.
The New Architecture
Instead of one massive prompt, the framework now has two layers:
Layer 1: Minimal Core (~1.5KB)
The CLAUDE.md file contains just the essentials—realm definitions, detection patterns, imbalance recognition. Enough for Claude to operate with ADD awareness without loading everything.
Layer 2: Skills On Demand
Deep support lives in focused skill files that load only when relevant:
.claude/skills/
├── add-flow-check.md # Automatic status updates
├── add-status.md # /add-status command
├── add-reflect.md # Session reflection
├── add-assess.md # Assess realm support
├── add-decide.md # Decide realm support
├── add-do.md # Do realm support
└── add-imbalance.md # Stuck pattern detectionLet’s Look at the Numbers
| Approach | Base Load | Additional |
|---|---|---|
| Megaprompt (before) | ~26KB every time | None |
| Skills (after) | ~1.5KB | ~2KB per skill when needed |
That’s 94% less context overhead for typical conversations.
New Capabilities
1. User Commands
Users can now explicitly check their flow:
/add-statusResponse:
[ADD Flow: 🟠? Decide | Narrowing phase - 3 options → 1 finalist]
Session Metrics:
- Exchanges this session: 12
- Realm transitions: 3
- Time in current realm: 4 exchanges
- Flow quality: BalancedBefore, users had to ask “where am I in my flow?” and hope Claude remembered to track it. Now there’s an explicit command.
2. Automatic Status Updates
The add-flow-check skill is model-invocable—Claude calls it automatically at conversation boundaries. The status file updates silently, and the visual statusline at the bottom of Claude Code shows current state.
Before, this required Claude to “remember” to update status. Now it’s built into the system.
3. Session Reflection with Isolated Context
This is the biggest improvement. The /add-reflect command analyzes your entire session for patterns:
/add-reflect
Session reflection captured.
Quick summary:
- Flow quality: Balanced
- Realm focus: Assess-heavy (exploration phase)
- Key insight: Thorough foundation built for upcoming decisions
Full reflection saved to .add-session-history.mdThe icing on the cake: this runs in a forked context. The reflection analysis—which requires reviewing the entire conversation—happens in an isolated subagent. Your main conversation stays clean. The history file accumulates over time, letting you see patterns across sessions.
Before skills supported subagents, this kind of reflection would clutter your working context with meta-analysis. Now it’s cleanly separated.
Practical Examples
When You’re Stuck in Research Mode
Imagine you’ve been exploring authentication approaches for 15 exchanges. The status bar shows:
[ADD Flow: 🔴+ Assess | Circular pattern - revisiting authentication 3x]The pattern is surfaced and made visible. Claude’s responses gently acknowledge the depth of exploration without pushing you to decide before you’re ready.
When You Jump to Execution Too Fast
You say “How do I implement OAuth?” without any context. Claude recognizes this pattern:
“Before we dive into implementation, let’s explore what you need. What’s driving the authentication requirement? Understanding the ‘why’ helps ensure the ‘how’ actually fits.”
The add-imbalance skill provides this guidance—but only loads when the pattern is detected.
When You Complete Something
You finish a task. The framework recognizes this as a “liveline”—not an ending, but a new beginning:
[ADD Flow: 🟢- Do | Liveline created - completion opening new assessment]“That’s done. What does this completion open up? What’s emerging in the space it creates?”
The cycle continues naturally.
What This Means for Framework Integration
The ADD evolution demonstrates something broader: AI frameworks benefit from the same architecture principles as software.
The megaprompt was a monolith. It worked, but it was inefficient.
The skills approach is modular:
- Separation of concerns — Each skill handles one thing
- Progressive loading — Context loads on demand
- Isolated execution — Subagents don’t pollute main context
- User control — Commands give explicit access
This pattern applies to any framework you might integrate with Claude. Instead of one massive prompt, consider:
- Core awareness — Minimal instructions that load every time
- Modular skills — Detailed support that loads when relevant
- User commands — Explicit actions users can invoke
- Background automation — Model-invocable skills that maintain state
Getting Started
If you want to try the ADD framework:
For Claude Code Users (Recommended)
Fork or clone the repository. The skills-first architecture activates automatically:
CLAUDE.mdloads minimal core awareness (~1.5KB)- Skills in
.claude/skills/activate on demand - Try
/add-statusand/add-reflectcommands - Watch the statusline for real-time realm tracking
For claude.ai or Claude Desktop
These don’t support skills yet. Use the megaprompt approach:
- Download
docs/ADD_FRAMEWORK_MEGAPROMPT_USER_CONTEXT.md - Attach it to your conversation or add to Custom Instructions
The megaprompt still works great—it’s just not as efficient as skills.
The Bigger Picture
What started as a personal productivity framework became an iOS app, then a Claude integration, and now a native skills implementation. Each evolution taught me something:
- Frameworks work when they match how humans actually think — ADD succeeds because it names states people already experience
- AI can learn cognitive frameworks — Not through training, but through well-structured prompts
- Architecture matters — The same logic runs better when properly modularized
The skills merge in Claude Code wasn’t designed for ADD. It was designed for general extensibility. But it enabled exactly what ADD needed: dynamic loading, user commands, and isolated reflection.
Sometimes the platform evolves in ways that make your specific use case dramatically better. This was one of those times.
Resources
The ADD framework is open source and available for anyone to use or adapt. The skills implementation works with Claude Code as of January 2026.
dragos@dragosroua.com (Dragos Roua)
Source link