Feb 4, 2026 Feb 4, 2026 2026-02-04

A few months ago I published a mega prompt that teaches Claude to think with the Assess-Decide-Do framework. I wrote about it on Reddit and the post got 40,000 views in 19 hours, 282 shares, and the GitHub repo collected 67 stars and 14 forks. My first sponsor showed up within a week.

That was nice. But what happened next was a little bit more interesting.

Two separate upgrades in Claude’s ecosystem opened doors I didn’t expect. And after a bit of tinkering, what started as a single mega prompt is now a three-repo architecture that works across different Claude environments. Here’s the story.

Quick Background: What ADD Does to Claude

If you’re new here: the Assess-Decide-Do framework is a 15-year-old methodology I created for managing how we actually think. Not just churning out tasks, but how we actually function. It maps three cognitive realms: Assess (explore without commitment), Decide (choose and commit), Do (execute and complete).

When you teach this to Claude, something interesting happens. Instead of generic responses, Claude detects where you are in your process and responds accordingly. Exploring options? It stays expansive. Ready to commit? It helps you choose. Executing? It gets out of the way and supports completion.

The original integration was a big markdown file (the “mega prompt”) that you loaded into Claude Desktop or Claude Code conversations. It worked, but it was monolithic. One file trying to do everything.

Upgrade #1: Claude Code Merged Skills and Commands

Claude Code used to have a split between slash commands (things you invoke explicitly) and skills (things Claude uses on its own based on context). Then Anthropic merged them. Skills became loadable on demand, with proper frontmatter metadata that tells Claude when and how to use each one.

This was the opening I didn’t expected.

Instead of one massive mega prompt, I could split ADD into modular skills. Each realm got its own skill file. Imbalance detection became its own skill. Flow status tracking became its own skill. Claude Code picks them up automatically based on what’s happening in the conversation.

The update also let me build something I’m quite proud of: a status line display. While you work, Claude Code shows a visual indicator of your current ADD state. Something like:

[ADD Flow: 🔴+ Assess | Deep exploration - 8 data points gathered]

Or when you’re executing:

[ADD Flow: 🟢- Do | Clean execution - 3 tasks completed]

It’s a small thing, but seeing your cognitive state reflected back to you in real time changes how you work. It makes the invisible visible. The updated Claude Code repo is here: github.com/dragosroua/claude-assess-decide-do-mega-prompt

Upgrade #2: Claude Cowork Launched Plugins

Then Anthropic launched Cowork with a plugin system. Cowork is a desktop tool for non-developers, focused on file and task management. It supports skills (same concept as Claude Code) and commands (slash-invoked actions specific to the plugin).

This meant ADD could work outside the developer terminal. Someone who’s never touched Claude Code could install a plugin and get realm-aware Claude through simple commands like /assess, /decide, /do.

Building the plugin required adapting the framework. Cowork doesn’t have filesystem access like Claude Code, so there’s no status line file. Instead, the /status command analyzes conversation context to detect your current realm. The /balance command runs a diagnostic, asking a few targeted questions and telling you if you’re over-assessing, over-deciding, or stuck in perpetual doing.

The Cowork plugin repo: github.com/dragosroua/add-framework-cowork-plugin

The Problem: Two Repos, Same Knowledge, Different Formats

At this point I had two implementations. Both contained ADD knowledge, but each had environment-specific features baked in. The Claude Code version referenced status files and subagent contexts. The Cowork version had slash commands and conversation-based detection.

If I updated the core philosophy (say, refining how imbalance detection works), I’d have to update it in two places. That’s how knowledge drift starts. And with a framework I’ve been refining for 15 years, drift is not acceptable.

The Solution: A Shared Skills Repo

The fix was straightforward. Extract all universal ADD knowledge into a standalone repository. No environment-specific features. No slash commands. Just the pure framework: realm definitions, detection patterns, imbalance recognition, response strategies, the “liveline” philosophy, the cascade principle, fractal operation.

Six skills, each in its own folder:

• add-core: Unified overview of the entire framework
• add-assess: Deep Assess realm support
• add-decide: Deep Decide realm support (including the Livelines vs. Deadlines concept)
• add-do: Deep Do realm support
• add-imbalance: Five detailed imbalance patterns with intervention strategies
• add-realm-detection: Centralized detection patterns for all realms

The shared skills repo: github.com/dragosroua/add-framework-skills

Both Claude Code and Cowork repos pull from this shared source using git subtree. Update once, pull everywhere.

How the Three Repos Connect

add-framework-skills (source of truth) contains the universal ADD methodology. No environment assumptions.

claude-assess-decide-do-mega-prompt (Claude Code) pulls the shared skills and adds Claude Code-specific features: status line display, automatic flow checking, subagent-powered session reflection.

add-framework-cowork-plugin (Cowork) pulls the shared skills and adds Cowork-specific features: /assess, /decide, /do, /status, /balance, and /add-help commands.

If you’re a developer using Claude Code, start with the mega prompt repo. If you use Cowork, grab the plugin. If you want to integrate ADD into something else entirely, the shared skills repo is your starting point.

Honest Caveats

This is still raw around the edges. Cowork plugins are new, and the plugin ecosystem is evolving. The shared skills format might need adjustments as both Claude Code and Cowork mature. I’m learning the boundaries of what each environment supports as I go.

What I’m really testing here is something bigger than a productivity framework: can we map human cognitive patterns onto performant AI in a way that augments us rather than making us dependent?

Most AI interactions today are transactional. You ask, it answers. You prompt, it generates. The human adapts to the machine.

ADD integration tries to work around this. The AI adapts to the human’s cognitive state. It detects where you are in your thinking and responds accordingly. It notices when you’re stuck and offers gentle guidance. It respects the boundaries between exploration, commitment, and execution.

This isn’t prompt engineering in the traditional sense. It’s cognitive alignment. A 15-year-old, battle-tested framework meeting the power of performant AI. And with the three-repo architecture, it can now expand to any Claude environment that supports skills.

The repos are public. The framework is open. If you want AI that works with your mind instead of against it, pick whichever repo fits your setup and give it a try.

---

All three repos are MIT licensed and available on GitHub. If you want to see ADD in action as a native app, addTaskManager implements the full framework on iOS and macOS.