Purpose: Load ADD framework as foundational context for all Claude interactions within a project
Implementation:
# .claude file structure
project:
name: "ADD Framework Integration"
frameworks:
- ADD (Assess-Decide-Do)
instructions: |
This project operates under the Assess-Decide-Do (ADD) life management framework.
Every interaction should be processed through ADD lens:
1. Assess which realm the user is operating in
2. Decide on appropriate response strategy
3. Do: Execute the response
Refer to ADD_FRAMEWORK_MEGAPROMPT.md for complete framework details.
Realm indicators:
- Assess: exploration, "what if", open-ended questions, information gathering
- Decide: "should I", prioritization, commitment language, resource allocation
- Do: "how do I", execution steps, completion focus
Detect imbalances:
- Analysis paralysis (stuck in Assess)
- Decision avoidance (Assess-Decide gap)
- Execution without foundation (Assess-Do shortcut)
- Perpetual doing (Do realm stuck)
Guide users toward balanced flow between realms.
context_files:
- ADD_FRAMEWORK_MEGAPROMPT.md
- addtaskmanager_philosophy.md (if available)
Note on Mega Prompt Variants:
ADD_FRAMEWORK_MEGAPROMPT.md- Generic version for all usersADD_FRAMEWORK_MEGAPROMPT_USER_CONTEXT.md- Contains personalized user context section- Template for users wanting to add their own ADD background/context
- Edit the "INTEGRATION WITH USER CONTEXT" section before using
- Helps Claude understand your specific relationship with the framework
Purpose: Create an ADD-aware integration that enforces realm boundaries programmatically
Concept: Similar to your addTaskManager MCP server, but generalized for all ADD interactions
// Conceptual MCP Server Structure
interface ADDFrameworkServer {
// Realm Detection
detectRealm(userInput: string): 'assess' | 'decide' | 'do'
// Realm Validation
validateRealmTransition(from: Realm, to: Realm): boolean
// Imbalance Detection
detectImbalance(conversationHistory: Message[]): ImbalanceType | null
// Response Structuring
structureResponse(realm: Realm, content: string): StructuredResponse
// Tool Use Validation (ensure tools respect realm boundaries)
validateToolUse(tool: string, realm: Realm): boolean
}
// Example Realm Restrictions for Tool Use
const TOOL_REALM_RULES = {
assess: {
allowed: ['web_search', 'web_fetch', 'view', 'conversation_search'],
forbidden: ['create_file', 'reminder_create', 'event_create'] // no commitment tools
},
decide: {
allowed: ['reminder_create', 'event_create', 'calendar_search'],
forbidden: ['web_search', 'create_file'] // no new exploration or execution
},
do: {
allowed: ['create_file', 'bash_tool', 'str_replace', 'reminder_update'],
forbidden: ['web_search'] // no re-assessment during execution
}
}Purpose: Track realm state across conversation for continuity
// Memory Tag Structure
interface ADDMemoryTag {
currentRealm: 'assess' | 'decide' | 'do'
realmHistory: RealmTransition[]
detectedImbalances: Imbalance[]
zenStatus: {
assess: number // count of items in assess
decide: number // count of items in decide
do: number // count of items in do
balance: 'high' | 'medium' | 'low'
}
lastRealmTransition: timestamp
}
// Stored in conversation memory
// Accessed via memory system to maintain continuityPurpose: Create ADD-aware skills that respect realm boundaries
# Example Skill: ADD Project Planning Skill
## Skill Purpose
Guide users through complete ADD cycle for project planning
## Skill Structure
### Phase 1: ASSESS
1. Explore project vision and possibilities
2. Gather relevant information
3. Identify stakeholders and constraints
4. Dream about ideal outcomes
5. **RESTRICT**: No timeline decisions, no resource commitments
### Phase 2: DECIDE
1. Evaluate options from Assess
2. Prioritize project elements
3. Allocate time and resources
4. Make commitment decisions
5. Define success metrics
6. **RESTRICT**: No content changes, no execution
### Phase 3: DO
1. Create implementation structure
2. Execute defined tasks
3. Track completion
4. **RESTRICT**: No re-assessment, no re-deciding (loop back to new Assess cycle instead)
## Skill Triggers
- User mentions "project planning"
- User shows imbalance between realms
- User requests structured approach to complex initiative
## Skill Integration
This skill enforces ADD realm boundaries while supporting complete project lifecycle.Purpose: Automatically categorize and route requests through ADD lens before main processing
# Conceptual Preprocessing Pipeline
def preprocess_request(user_input: str, context: ConversationContext) -> ProcessedRequest:
"""
Preprocess every request through ADD framework before main processing
"""
# Step 1: Detect Realm
realm = detect_realm_from_input(user_input)
# Step 2: Check for Imbalances
imbalance = detect_imbalance(context.history, realm)
# Step 3: Determine Intervention Strategy
strategy = decide_response_strategy(realm, imbalance, context)
# Step 4: Structure Processing Instructions
instructions = {
'realm': realm,
'imbalance': imbalance,
'strategy': strategy,
'realm_restrictions': get_realm_restrictions(realm),
'suggested_tools': get_realm_appropriate_tools(realm),
'response_structure': get_realm_response_template(realm)
}
return ProcessedRequest(
original_input=user_input,
add_instructions=instructions,
enhanced_prompt=construct_enhanced_prompt(user_input, instructions)
)
# Realm Detection using NLP patterns
def detect_realm_from_input(text: str) -> Realm:
assess_indicators = ['what if', 'exploring', 'thinking about', 'considering',
'not sure', 'possibilities', 'options']
decide_indicators = ['should i', 'need to choose', 'priority', 'commit',
'when should', 'which one', 'best option']
do_indicators = ['how do i', 'steps to', 'complete', 'finish',
'working on', 'executing', 'doing']
# Score each realm based on indicator presence
scores = {
'assess': count_indicators(text, assess_indicators),
'decide': count_indicators(text, decide_indicators),
'do': count_indicators(text, do_indicators)
}
return max(scores, key=scores.get)Add to Claude's custom instructions (via Settings):
Framework Integration: Assess-Decide-Do (ADD)
Process every request through ADD lens:
1. Identify which realm (Assess/Decide/Do) the request belongs to
2. Structure response appropriate to that realm
3. Detect and address realm imbalances
Realm recognition:
- Assess: Exploratory, "what if", information gathering
- Decide: "Should I", commitment, priority setting
- Do: "How do", execution, completion
Support balanced flow. Avoid analysis paralysis, decision avoidance,
and execution without foundation.
Start each relevant conversation with ADD activation:
This conversation will use the Assess-Decide-Do (ADD) framework.
Please load ADD_FRAMEWORK_MEGAPROMPT.md and operate with ADD lens throughout.
Place in project root:
project:
name: "My ADD-Organized Project"
framework: Assess-Decide-Do
instructions: |
All interactions use ADD framework. See ADD_FRAMEWORK_MEGAPROMPT.md for details.
Track realm state. Guide balanced flow. Detect imbalances.
Create specialized agents for each realm:
agents:
assess_agent:
role: "Assessment & Exploration Specialist"
capabilities:
- Information gathering
- Possibility exploration
- Pattern recognition
- No decision-making or execution
decide_agent:
role: "Decision & Prioritization Specialist"
capabilities:
- Priority assessment
- Resource allocation
- Commitment facilitation
- No content editing or execution
do_agent:
role: "Execution & Completion Specialist"
capabilities:
- Task execution
- Completion tracking
- Implementation support
- No re-assessment or re-deciding
orchestrator:
role: "ADD Flow Coordinator"
capabilities:
- Route to appropriate realm agent
- Detect imbalances
- Guide realm transitions
- Maintain overall balanceInput: "I've been thinking about starting a blog. What are some possible topics I could write about?" Expected: Detect ASSESS realm, provide expansive exploratory response, avoid decision pressure
Input: [After 5 messages of exploration] "Maybe I should research 10 more blog niches first?" Expected: Detect ASSESS imbalance, gently guide toward DECIDE realm
Input: "I've narrowed it to 3 blog topics. How do I choose?" Expected: Detect DECIDE realm, support values-based decision-making without deciding for user
Input: "I want to write an ebook. What's the best writing software?" Expected: Detect skipped ASSESS phase, slow down and invite assessment before execution
Input: [User in DECIDE] "Actually, can you help me explore more options?" Expected: Recognize realm transition request, validate completing current Decide cycle first or starting new Assess cycle
Input: "I just finished writing the ebook!" Expected: Celebrate DO completion, frame as "liveline" (new starting point), invite ASSESS for next cycle
interface ADDPerformanceMetrics {
// Realm Detection Accuracy
realmDetectionAccuracy: number // % correct realm identification
// Imbalance Detection
imbalancesDetected: number
imbalancesResolved: number
// Flow Guidance
realmTransitionsGuided: number
balancedCyclesCompleted: number
// User Experience
realmConfusionIncidents: number // user confused about which realm
naturalIntegrationScore: number // framework felt natural vs forced
userBalanceImprovement: number // zen status improvement over time
}When using bash_tool, create_file, etc., enforce ADD flow:
class ADDCodeExecutor:
"""
Wrapper around code execution tools that enforces ADD framework
"""
def execute_with_add_flow(self, task):
# ASSESS phase
assessment = self.assess_code_task(task)
if not assessment.complete:
return "Need more assessment before execution"
# DECIDE phase
decision = self.decide_implementation(assessment)
if not decision.committed:
return "Need decision commitment before execution"
# DO phase
result = self.execute_implementation(decision)
return self.complete_and_cycle(result)
def assess_code_task(self, task):
"""Gather requirements, explore approaches"""
return {
'requirements_clear': bool,
'approaches_explored': list,
'constraints_identified': list,
'complete': bool
}
def decide_implementation(self, assessment):
"""Choose specific implementation strategy"""
return {
'chosen_approach': str,
'architecture_decided': bool,
'resources_allocated': dict,
'committed': bool
}
def execute_implementation(self, decision):
"""Actually write and run the code"""
# Only called if Assess and Decide are complete
passSince you (Dragos) have the addTaskManager app, Claude could potentially integrate with it:
// Claude could use your existing addTaskManager MCP server
// to create/manage tasks while respecting ADD realm boundaries
async function createTaskWithADD(content: string, currentRealm: Realm) {
if (currentRealm === 'assess') {
// Only create in Assess realm, no context/dates
await mcp.callTool('create_task', {
realm: 'assess',
content: content,
// NO context or due date allowed
})
}
if (currentRealm === 'decide') {
// Move to Decide realm, assign context/dates
await mcp.callTool('update_task', {
taskId: taskId,
realm: 'decide',
context: context,
dueDate: dueDate,
// NO content editing allowed
})
}
if (currentRealm === 'do') {
// Mark complete only
await mcp.callTool('complete_task', {
taskId: taskId,
realm: 'do'
})
}
}Track how well ADD integration is working:
interface ADDIntegrationHealth {
// Framework Application
requests_processed_with_add: number
realm_detection_confidence: number
// Balance Metrics
assess_realm_sessions: number
decide_realm_sessions: number
do_realm_sessions: number
balanced_cycles_completed: number
// Problem Detection
analysis_paralysis_incidents: number
decision_avoidance_incidents: number
execution_shortcuts: number
perpetual_doing_incidents: number
// Intervention Effectiveness
gentle_guidances_issued: number
realm_transitions_supported: number
imbalances_corrected: number
// User Satisfaction
user_found_helpful: boolean
felt_natural_vs_forced: rating
improved_workflow_balance: boolean
}The ADD integration should evolve:
- Framework operates below surface
- Users benefit without conscious awareness
- Natural conversation flow
- Claude names realms when useful
- Explains ADD when it clarifies
- User learns framework through use
- User and Claude co-evolve ADD application
- Discover new patterns together
- Refine realm boundaries for specific contexts
- ADD for relationships
- ADD for health/fitness
- ADD for business strategy
- ADD for creative work
- Each domain gets specialized realm definitions
The deepest integration would be at the model training level, but since we can't retrain Claude, we achieve deep integration through:
- Prompt engineering (mega prompt)
- Architectural patterns (preprocessing, MCP servers)
- Memory systems (realm state tracking)
- Tool restrictions (realm-appropriate tool use)
- Response structuring (realm-specific templates)
Together, these create an integration that feels like native ADD support even though it's implemented at the prompt level.
Next Steps:
- Test the mega prompt across various interaction types
- Identify gaps or areas needing refinement
- Consider implementing MCP server for stricter enforcement
- Build out domain-specific ADD implementations
- Create feedback loop for continuous improvement