Jan 28, 2026 Jan 28, 2026 2026-01-28

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:

1. Progressive disclosure — Skills load context dynamically, only when needed
2. 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 detection

Let’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-status

Response:

[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: Balanced

Before, 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.md

The 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:

1. Core awareness — Minimal instructions that load every time
2. Modular skills — Detailed support that loads when relevant
3. User commands — Explicit actions users can invoke
4. 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.md loads minimal core awareness (~1.5KB)
• Skills in .claude/skills/ activate on demand
• Try /add-status and /add-reflect commands
• 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

• ADD Framework Claude Integration Repository (GitHub)
• ADD Resources and Blog Posts (2010 – 2026)
• addTaskManager App (iOS/macOS)

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.