Claude Configuration Reference

Auto-generated from .claude/CLAUDE.md. Run npm run docs:generate to refresh.

This page documents the Claude Code configuration for the Mahoosuc OS project — covering slash commands, agents, workflows, and integration patterns.

42 slash commands documented across multiple categories.

Project Overview
Core Philosophy
Slash Command Usage
Agent Routing Guidelines
Approval Workflows
Compound Engineering System
Available Skills
Comprehensive Slash Commands
Resource References
Development Workflow
Quality Standards
Troubleshooting
Important Notes
Claude Code Infrastructure (v3.0)

Prompt Blueprint - Claude Code Configuration

Project Overview

This project is a comprehensive AI agent orchestration system that combines:

Prompt Engineering Knowledge Base: Best practices from OpenAI, Anthropic, Google
Meta-Agents: AI agents that create other AI agents
Zoho ONE Integration: CRM, Mail, and SMS automation
Multi-Interface System: CLI slash commands, web UI, and Zoho widgets

Core Philosophy

Data Model Enhancement

ENHANCE the data model by ADDING columns/fields - We can remove them later after systems are functioning
ENHANCE OVER REMOVING - Always prefer to add functionality rather than remove existing code
Iterate with expansion - Build comprehensive systems first, optimize second

Zoho ONE Integration Priority

CRM: All lead, contact, and deal management flows through Zoho CRM
MAIL: Email campaigns and communications via Zoho Mail
SMS: SMS campaigns and notifications via Zoho SMS
All Zoho operations require human approval before execution

Slash Command Usage

Compound Engineering Workflow Commands (NEW)

Based on the principle that each unit of work should make subsequent work easier through systematic knowledge capture.

ArchitectFlow (Planning with git worktrees):

/architect:plan --title "Feature Name" - Create planning session with isolated git worktree
/architect:review [workflow-id] --wait - Trigger multi-agent review (Security, Performance, Architecture, Testing)

DevFlow (In-sprint reviews with git branches):

/devflow:review --title "Feature Name" - Create in-sprint review session with git branch
/devflow:compound --category pattern --title "..." --impactScore 8 - Capture compound learnings

Learning Categories:

pattern - Reusable design or code pattern discovered
anti-pattern - Pattern to avoid (learned the hard way)
best-practice - Recommended approach that worked well
gotcha - Common pitfall or mistake to watch out for
tip - Helpful hint or optimization trick

Knowledge Integration:

Learnings automatically integrate into CLAUDE.md and DEVB knowledge base
30-day TTL with archive option for cleanup
Tag-based semantic search for retrieval
Impact scoring (1-10) for prioritization

Multi-Agent Reviews:

4 specialized AI agents run in parallel via worker queue
Security: Vulnerabilities, auth issues, crypto weaknesses
Performance: N+1 queries, algorithm complexity, caching opportunities
Architecture: SOLID principles, design patterns, coupling issues
Testing: Coverage gaps, edge cases, flaky tests

DEVB (Design-Emulate-Validate-Build) System Commands

/design:solution - Create comprehensive solution design specification
/design:emulate [design-id] - Test design without building (3 methods: dry-run, static-analysis, simulation)
/design:validate [design-id] - AI validation from 4 perspectives (Security, Performance, Cost, UX)
/design:spec [design-id] - Generate complete specifications (diagrams, OpenAPI, test plan, checklist)

Design OS Commands (Product Planning & UI Design)

The Design OS workflow provides a structured approach to product design before implementation:

Phase 1: Product Planning

/design-os/product-vision - Define product vision, problems, solutions, and key features
/design-os/product-roadmap - Create 3-5 buildable sections ordered by priority
/design-os/data-model - Define core data entities and relationships

Phase 2: Design System

/design-os/design-tokens - Set colors (Tailwind) and typography (Google Fonts)
/design-os/design-shell - Create app navigation shell and layout

Phase 3: Section Design (repeat per section)

/design-os/shape-section <section> - Define section specs, flows, UI patterns
/design-os/sample-data <section> - Generate realistic sample data + TypeScript types
/design-os/design-screen <section> - Create production-grade React components
/design-os/screenshot-design <section> - Capture screenshots for documentation

Phase 4: Export

/design-os/export-product - Generate complete implementation handoff package

Prompt Engineering Commands

/prompt/generate [description] - Generate new AI prompts using PromptCraft∞ Elite agent
/prompt/review [file] - Review prompts against unified best practices
/prompt/optimize [file] - Optimize existing prompts for better performance
/prompt/test [file] - Test prompt variants and compare results

Zoho Operations Commands

/zoho/create-lead [details] - Create CRM lead with approval workflow
/zoho/send-email [recipient] [template] - Send email via Zoho Mail
/zoho/send-sms [recipient] [message] - Send SMS via Zoho SMS
/zoho/sync-data [source] [target] - Sync data between systems
/zoho/query-crm [query] - Query CRM using natural language

Agent Coordination Commands

/agent/route [task] - Automatically route task to best agent
/agent/status - Check all agent statuses and performance
/agent/assign [task] [agent] - Manually assign task to specific agent
/agent/monitor - Real-time agent activity monitor

Workflow Commands

/workflow/approve [pending-id] - Approve pending operations
/workflow/collect-data [form-type] - Start structured data collection

Agent OS Commands (Spec-Driven Development)

The Agent OS workflow provides spec-driven feature development with specialized agents:

Phase 1: Planning

/agent-os/plan-product - Create product mission, roadmap, and tech stack

Phase 2: Specification (per feature)

/agent-os/init-spec <feature> - Initialize spec folder and capture initial idea
/agent-os/shape-spec <feature> - Gather requirements through targeted questions
/agent-os/write-spec <feature> - Create detailed specification document
/agent-os/verify-spec <feature> - Validate spec completeness and alignment

Phase 3: Contract & Integration (NEW - Full-Stack Unification)

/agent-os/design-contract <feature> - Create unified API contracts (types, errors, endpoints)
/agent-os/design-integration <feature> - Design data fetching, caching, error handling patterns

Phase 4: Implementation

/agent-os/create-tasks <feature> - Create organized task list with dependencies
/agent-os/implement-tasks <feature> - Execute tasks with test-driven development
/agent-os/verify-implementation <feature> - Verify completion and update roadmap

Phase 5: Full-Stack Verification (NEW)

/agent-os/verify-integration <feature> - End-to-end frontend/backend verification

Specialized Agents (in .claude/agents/agent-os/):

Planning & Specification:

product-planner - Product documentation creation
spec-initializer - Spec folder setup
spec-shaper - Requirements gathering
spec-writer - Specification writing
spec-verifier - Spec validation

Full-Stack Integration (NEW):

contract-designer - Unified API contracts shared by frontend & backend
integration-architect - Data fetching, state management, error handling patterns
full-stack-verifier - End-to-end integration verification

Implementation:

tasks-list-creator - Task breakdown
implementer - Full-stack implementation
implementation-verifier - Final verification

Standards (in .claude/standards/):

global/ - Coding style, conventions, error handling, validation, tech stack, API contracts
frontend/ - Component patterns, accessibility, performance
backend/ - API design, database, security, architecture
testing/ - Unit, integration, E2E testing patterns

Agent Routing Guidelines

When to Use Which Agent

For Prompt Engineering:

Use prompt-engineering-agent from /meta-prompts/ for creating new prompts
Use documentation-expert-agent for creating/updating documentation
Reference /guides/unified-best-practices__claude_sonnet_4.md for best practices

For Zoho Integration:

Route CRM operations through Zoho CRM integration patterns
Route email operations through Zoho Mail integration patterns
Route SMS operations through Zoho SMS integration patterns
Always include approval workflow for data modifications

For Multi-Agent Coordination:

Use agent-router patterns to determine best agent for task
Use workflow orchestration for complex multi-step processes
Maintain context sharing between agents

Approval Workflows

All operations that modify data require human approval:

CRM Operations (create lead, update contact, create deal)
- Preview data to be created/modified
- Show which fields will be populated
- Request explicit confirmation
- Log approval decision
Communication Operations (send email, send SMS)
- Show full message content
- Display recipient list
- Preview merge fields/personalization
- Confirm send authorization
Data Sync Operations (sync between systems)
- Show data mapping
- Display records to be affected
- Highlight any conflicts
- Require confirmation to proceed

Compound Engineering System

Philosophy: 80/20 Planning vs. Execution

Based on the principle that each unit of work should make subsequent work easier through systematic knowledge capture. Invest 80% of effort in planning and review, 20% in execution.

Two Workflow Types

1. ArchitectFlow (Upfront Planning)

Use for: Major features, architectural changes, greenfield projects Git Strategy: Isolated worktrees in /tmp/architect-{sessionId} Purpose: Deep architectural planning before implementation

Workflow:

## Step 1: Create planning session

/architect:plan --title "Microservices Architecture"

## Claude creates:

## - Workflow session in database

## - Git worktree at /tmp/architect-{sessionId}

## - Branch: plan/{sessionId}

## Step 2: Work in isolated environment

cd /tmp/architect-{sessionId}

## Do planning work, create diagrams, write specs

## Step 3: Trigger multi-agent review (optional)

/architect:review {workflow-id} --wait --captureLearnings

## Step 4: Capture learnings

/devflow:compound {workflow-id} --category pattern --title "..."

Benefits:

Parallel planning sessions possible
No interference with main workspace
Clean separation of concerns
Automatic cleanup via 30-day TTL

2. DevFlow (In-Sprint Reviews)

Use for: Mid-sprint quality checks, pre-merge reviews, feature completion Git Strategy: Lightweight branches review/{feature-name} Purpose: Quick reviews during active development

Workflow:

## Step 1: Create review session

/devflow:review --title "Authentication System" --reviewType security

## Claude creates:

## - Workflow session in database

## - Git branch: review/authentication-system-{short-id}

## - Queues review agents

## Step 2: Wait for review (optional)

/devflow:review --title "..." --wait --autoCompound

## Step 3: Manually capture important learnings

/devflow:compound --category gotcha --title "N+1 Queries" --impactScore 10

Multi-Agent Parallel Reviews

When you trigger a review with --reviewType all, the system queues 4 specialized AI agents to run in parallel:

1. Security Agent

Checks:

SQL injection, XSS, CSRF vulnerabilities
Authentication and authorization issues
Sensitive data exposure
Cryptographic weaknesses
Dependency vulnerabilities (CVEs)

Output Format:

{
  "severity": "critical|high|medium|low|info",
  "category": "sql-injection|xss|auth|crypto|...",
  "title": "Potential SQL Injection Vulnerability",
  "file": "src/database/queries.ts",
  "line": 42,
  "recommendation": "Use parameterized queries",
  "fixExample": "const result = await db.query('SELECT * FROM users WHERE id = $1', [userId]);"
}

2. Performance Agent

Checks:

N+1 query problems
Inefficient algorithms (O(n²) loops)
Memory leaks
Missing caching opportunities
Inefficient database queries

3. Architecture Agent

Checks:

SOLID principle violations
Circular dependencies
God classes (too many responsibilities)
Tight coupling
Missing abstractions

4. Testing Agent

Checks:

Missing test coverage
Weak assertions
Flaky tests
Untested edge cases
Integration test gaps

Parallel Execution:

All 4 agents run concurrently via Redis worker queue
Total time: 3-5 minutes (vs. 12-20 minutes sequential)
Results aggregated in review_sessions.agent_results JSONB field

Knowledge Compounding

Learning Categories

Pattern (✨) - Reusable design or code pattern
- Example: “Repository Pattern for Database Access”
- Use when: You discover a useful pattern worth repeating
Anti-Pattern (⚠️) - Pattern to avoid
- Example: “God Classes with 500+ Lines”
- Use when: You identify something that causes problems
Best Practice (✅) - Recommended approach
- Example: “Always Use Parameterized Queries”
- Use when: You find an approach that works well
Gotcha (🔥) - Common pitfall or mistake
- Example: “N+1 Queries in Loops”
- Use when: You discover a common mistake to watch for
Tip (💡) - Helpful hint or optimization
- Example: “Use const over let for Immutability”
- Use when: You find a small optimization or trick

Impact Scoring (1-10)

10: Game-changing insight that will save hours
8-9: Very valuable, will definitely use again
6-7: Useful knowledge worth remembering
4-5: Helpful but specific to this project
1-3: Minor observation

Automatic Integration

Learnings with impactScore >= 5 automatically integrate into:

CLAUDE.md - Project documentation
- Added to “Compound Learnings” section
- Formatted with category emoji
- Includes code examples, tags, file paths
- Searchable by Claude in future sessions
DEVB Knowledge Base - .claude/knowledge/devb-learnings.md
- Organized by category sections
- Cross-referenced with workflow sessions
- Feeds into DEVB AI analysis
PostgreSQL Database - compound_learnings table
- 30-day TTL with automatic archival
- Full-text search via tags and keywords
- Frequency tracking (how often pattern appears)

Search and Retrieval

## Search by keyword

GET /api/v1/learnings/search?q=repository

## Filter by category

GET /api/v1/learnings?category=pattern

## Filter by impact

GET /api/v1/learnings?minImpactScore=8

## Get statistics

GET /api/v1/learnings/stats

Database Features:

Tag-based search using PostgreSQL arrays
ILIKE for case-insensitive text search
Sorting by impact score and frequency
Automatic expiry via TTL triggers

Database Schema

Workflow Sessions

workflow_sessions (
  id UUID PRIMARY KEY,
  workflow_type VARCHAR(50),  -- 'architectflow' | 'devflow'
  title VARCHAR(255),
  git_worktree_path TEXT,     -- ArchitectFlow only
  git_branch_name TEXT,        -- DevFlow only
  git_base_branch VARCHAR(255),
  status VARCHAR(50),          -- 'planning' | 'reviewing' | 'completed' | 'archived'
  expires_at TIMESTAMP,        -- 30-day TTL
  ...
)

Review Sessions

review_sessions (
  id UUID PRIMARY KEY,
  workflow_session_id UUID REFERENCES workflow_sessions(id),
  review_type VARCHAR(50),     -- 'security' | 'performance' | 'architecture' | 'testing' | 'all'
  status VARCHAR(50),          -- 'pending' | 'in_progress' | 'completed' | 'failed'
  agent_results JSONB,         -- Array of agent results with findings
  processing_time_ms INTEGER,
  cost_in_cents DECIMAL,
  ...
)

Compound Learnings

compound_learnings (
  id UUID PRIMARY KEY,
  workflow_session_id UUID REFERENCES workflow_sessions(id),
  category VARCHAR(50),        -- 'pattern' | 'anti-pattern' | 'best-practice' | 'gotcha' | 'tip'
  title VARCHAR(255),
  description TEXT,
  code_example TEXT,
  tags TEXT[],                 -- PostgreSQL array
  file_paths TEXT[],
  impact_score INTEGER,        -- 1-10
  frequency_score INTEGER,     -- Auto-incremented on similar findings
  added_to_claude_md BOOLEAN,
  added_to_devb BOOLEAN,
  expires_at TIMESTAMP,        -- 30-day TTL
  ...
)

API Endpoints

Workflows:

POST /api/v1/workflows - Create workflow session
GET /api/v1/workflows - List workflows
GET /api/v1/workflows/:id - Get workflow details
PATCH /api/v1/workflows/:id/status - Update status
POST /api/v1/workflows/cleanup - Archive expired

Reviews:

POST /api/v1/reviews - Create review session
GET /api/v1/reviews/:id - Get review details
GET /api/v1/reviews/workflow/:workflowId - List by workflow
PATCH /api/v1/reviews/:id/status - Update status
GET /api/v1/reviews/stats - Get statistics

Learnings:

POST /api/v1/learnings - Create learning
GET /api/v1/learnings/:id - Get learning details
GET /api/v1/learnings - List with pagination/filters
GET /api/v1/learnings/search?q=query - Search learnings
GET /api/v1/learnings/stats - Get statistics
POST /api/v1/learnings/cleanup - Archive expired

Example Usage

Scenario: Planning a New Microservices Architecture

## 1. Start ArchitectFlow planning session

/architect:plan --title "E-Commerce Microservices" --autoReview

## Claude responds:

## ✅ ArchitectFlow planning session created

## 📂 Workspace: /tmp/architect-abc123

## 🌿 Branch: plan/abc123

## 🔍 Review queued: xyz789 (4 agents running)

## 2. Work in isolated worktree

cd /tmp/architect-abc123

## Create architecture diagrams, design documents, API specs

## 3. Wait for review to complete

/architect:review abc123 --wait --captureLearnings

## Claude responds:

## ✅ Review completed: E-Commerce Microservices

## 📊 Findings: 8 total

## 🔴 Critical: 1 (SQL injection in payment service)

## 🟠 High: 2 (Missing auth checks, N+1 queries)

## 🟡 Medium: 5

## ⏱️  Processing: 4200ms

## 💰 Cost: $0.068

## 4. Captured learnings appear in CLAUDE.md:

## ## Compound Learnings

## #### 🔥 SQL Injection in Payment Processing

## **Category:** gotcha | **Impact:** 10/10

## Always use parameterized queries when handling payment data...

## 5. Query learnings later

GET /api/v1/learnings/search?q=payment

Scenario: Mid-Sprint Code Review

## 1. Create DevFlow review for current feature

/devflow:review --title "User Authentication" --reviewType security --wait

## Claude responds:

## ✅ DevFlow review completed

## 🌿 Branch: review/user-authentication-def456

## 📊 Findings: 3 total

## 🟠 High: 1 (Weak password hashing)

## 🟡 Medium: 2

## 2. Manually capture critical learning

/devflow:compound --category anti-pattern \
  --title "Using MD5 for Password Hashing" \
  --description "MD5 is cryptographically broken. Use bcrypt or Argon2." \
  --impactScore 10

## Claude responds:

## ✨ Learning captured: Using MD5 for Password Hashing

## 📁 Category: anti-pattern

## ⭐ Impact: 10/10

## Integration:

## ✅ CLAUDE.md

## ✅ DEVB knowledge base

Available Skills

32 powerful skills are available to enhance your workflow (18 top-level + 14 Obra Superpowers sub-skills):

Original Skills (13)

stripe-revenue-analyzer - Financial analysis, customer insights, subscription health monitoring
brand-voice - Consistent AI solutioning brand voice for client-facing content
content-optimizer - Platform-specific content optimization (Reddit, LinkedIn, Twitter, HN, Discord)
vercel-landing-page-builder - Automated landing page creation with v0.dev and Vercel
frontend-design - Production-grade UI/UX avoiding generic AI aesthetics
qa-architect - Test automation, coverage analysis, test planning
security-auditor - Security analysis, vulnerability assessment, compliance
infra-as-code - Infrastructure as code patterns and deployment
vps-ops - VPS management and operations
release-manager - Release planning, feature flagging, rollout management
compliance-mapper - Compliance tracking and mapping
data-governance - Data governance and privacy policies
onprem-ops - On-premises infrastructure management

Vercel Skills (5 new)

ai-sdk - Vercel AI SDK integration for agents, chatbots, RAG, text generation
vercel-composition-patterns - React composition patterns and best practices
vercel-react-best-practices - React/Next.js performance optimization from Vercel Engineering
vercel-react-native-skills - React Native development patterns
web-design-guidelines - Latest Vercel web interface guidelines

Obra Superpowers (14 new - auto-activated based on context)

Skills from obra/superpowers that automatically trigger when relevant:

brainstorming - Structured brainstorming workflows
dispatching-parallel-agents - Multi-agent parallel coordination
executing-plans - Plan execution frameworks
finishing-a-development-branch - Branch completion checklists
receiving-code-review - Code review response workflows
requesting-code-review - Code review request templates
subagent-driven-development - Subagent delegation patterns
systematic-debugging - Structured debugging methodology
test-driven-development - TDD workflows and patterns
using-git-worktrees - Git worktree workflows for parallel work
using-superpowers - Meta-skill for understanding the framework
verification-before-completion - Pre-completion verification checklists
writing-plans - Plan writing templates and structure
writing-skills - Skill creation meta-workflows

Installation:

Vercel: npx skills add vercel-labs/agent-skills && npx skills add vercel/ai
Obra: git clone https://github.com/obra/superpowers.git && cp -r superpowers/skills .claude/skills/obra-superpowers

See .claude/SKILLS_REFERENCE.md for comprehensive skill documentation.

Comprehensive Slash Commands

This project includes 120+ slash commands across 45+ categories:

Quick Access by Category

Core Development:

/dev:* - Feature implementation, reviews, testing, CI/CD integration (10 commands)
/devops:* - Infrastructure, deployment, monitoring, cost optimization (8 commands)
/cicd:* - Pipeline setup, testing, deployment automation (4 commands)
/db:* - Database operations, migrations, backups (5 commands)

Data & Insights:

/finance:* - Financial reports, budgeting, tax planning, investments (5 commands)
/product:* - Positioning, pricing, investor reports, definitions (5 commands)
/startup:* - GTM strategy, metrics, idea validation, competitive analysis (5 commands)
/ai-search:* - Content optimization for AI search engines, citation tracking (4 commands)

Communication & Content:

/zoho:* - CRM, email, SMS operations with approval workflows (3 commands)
/scripts:* - Video, podcast, screenplay, dialogue generation (5 commands)
/research:* - Organization, annotation, summarization, citation (5 commands)
/brand:* - Brand asset management, mention monitoring (2 commands)

User Experience & Quality:

/accessibility:* - WCAG audits, fixes, automated testing (3 commands)
/auth:* - Authentication setup, testing, key rotation, compliance audits (4 commands)
/ui:* - Dashboard and interface management (1 command)

Personal & Team:

/assistant:* - Research, scheduling, task management, email handling (5 commands)
/travel:* - Trip planning, optimization, document management (5 commands)
/resume:* - Resume building, portfolio creation, LinkedIn optimization (5 commands)
/career:* - Job search, interview prep, salary negotiation (implied in resume commands)

Advanced Capabilities:

/integrations:* - Figma, Jira, Notion synchronization (3 commands)
/gamify:* - Game mechanics, reward systems, analytics (4 commands)
/model:analyze - Intelligent model selection and complexity analysis

Product Design:

/design-os:* - Product planning, design system, section design, export (10 commands)

Spec-Driven Development:

/agent-os:* - Spec initialization, shaping, writing, tasks, implementation (8 commands)

Complete reference: See .claude/SLASH_COMMANDS_REFERENCE.md for all 128+ commands with full documentation.

Resource References

DEVB System Documentation

.claude/DEVB_SYSTEM_GUIDE.md - Comprehensive guide to DEVB system (1,000+ lines)
DEVB System Architecture: Design → Emulate → Validate → Build (NVIDIA-inspired)
Use for: Any new feature, workflow chain, infrastructure, or complete solution design
Database Migration: shopify-dashboard/backend/postgres/migrations/011-devb-system.sql

Guides (Best Practices)

/guides/unified-best-practices__claude_sonnet_4.md - Primary reference (3,277 lines)
/guides/anthropic-best-practices__chatgpt-4_5.md - Anthropic-specific patterns
/guides/openai-best-practices__chatgpt-4_5.md - OpenAI-specific patterns
/guides/google-best-practices__chatgpt-4_5.md - Google-specific patterns

Meta-Prompts (Agent Definitions)

/meta-prompts/prompt-engineering-agent.md - PromptCraft∞ Elite (7-stage workflow)
/meta-prompts/documentation-expert-agent.md - Documentation specialist

Examples (Templates)

/examples/customer-support-agent.md - Customer support agent template

Patterns (Integration Strategies)

/patterns/integration/ - Zoho and external API patterns
/patterns/orchestration/ - Multi-agent coordination patterns
/patterns/interfaces/ - CLI, web, and Zoho widget patterns

Templates (Reusable Agents)

/templates/zoho-crm-agent.md - CRM operations specialist
/templates/zoho-mail-agent.md - Email operations specialist
/templates/zoho-sms-agent.md - SMS operations specialist
/templates/routing-coordinator-agent.md - Task routing coordinator

Development Workflow

Adding New Functionality

Enhance, don’t remove - Add new fields/columns to data model
Create meta-agent first - Define the AI agent for the new capability
Build integration pattern - Document how it integrates with existing systems
Create slash command - Make it accessible via CLI
Add to web interface - Expose in web UI (if applicable)
Integrate with Zoho - Connect to Zoho ONE systems (if applicable)
Test end-to-end - Validate complete workflow
Document thoroughly - Update guides and examples

Creating New Slash Commands

Create command file in appropriate subdirectory (.claude/commands/)
Use frontmatter for configuration (allowed-tools, argument-hint, description)
Reference existing agents and patterns from repository
Include human approval steps for data modifications
Test command thoroughly
Update README.md with command documentation

Creating New Agents

Use /meta-prompts/prompt-engineering-agent.md to generate agent definition
Follow the professional template structure:
- ROLE & EXPERTISE
- MISSION CRITICAL OBJECTIVE
- OPERATIONAL CONTEXT
- INPUT PROCESSING PROTOCOL
- REASONING METHODOLOGY
- OUTPUT SPECIFICATIONS
- QUALITY CONTROL CHECKLIST
- EXECUTION PROTOCOL
Save to /templates/ for reusable agents
Save to /examples/ for specific use case examples
Document integration patterns in /patterns/

Quality Standards

All Prompts Must:

Follow unified best practices from /guides/unified-best-practices__claude_sonnet_4.md
Include clear role definition and expertise areas
Specify operational context (domain, audience, quality tier)
Define input processing protocol
Specify reasoning methodology (CoT, ReAct, etc.)
Include quality control checklist
Provide execution protocol

All Integrations Must:

Include error handling and retry logic
Implement approval workflows for data modifications
Log all operations for audit trail
Handle rate limiting and API quotas
Provide clear error messages and recovery paths

All Slash Commands Must:

Have clear, descriptive names
Include helpful argument hints
Provide step-by-step execution
Reference relevant guides and patterns
Include success/failure criteria
Keep implementation under 10 major steps

Troubleshooting

Command Not Working?

Check command file syntax (markdown + optional frontmatter)
Verify file location (.claude/commands/[category]/[name].md)
Test with /help to see if command is listed
Check for typos in command name or arguments

Agent Not Behaving Correctly?

Review agent definition against template structure
Check if operational context is clear enough
Verify reasoning methodology is specified
Test with different inputs to isolate issue
Reference /guides/unified-best-practices__claude_sonnet_4.md for improvements

Zoho Integration Issues?

Verify API credentials and authentication
Check rate limits and quotas
Review approval workflow logs
Test with simpler operations first
Consult integration patterns in /patterns/integration/

Important Notes

Security: Never commit Zoho API credentials to version control
Performance: Cache frequently accessed CRM data to minimize API calls
Scalability: Design for multiple simultaneous agent operations
Monitoring: Track agent performance and success rates
Documentation: Keep guides and examples up to date with new capabilities

Claude Code Infrastructure (v3.0)

Hook System

Real Claude Code hooks are configured in .claude/settings.json using the official hook events:

Event	Script	Purpose
PreToolUse (Edit/Write)	`protect-sensitive-files.sh`	Blocks edits to .env, credentials, secrets, package-lock.json, .git/
PreToolUse (Bash)	`validate-docker-commands.sh`	Blocks destructive docker commands (rm, rmi, system prune)
PostToolUse (Bash)	`log-commands.sh`	Audit trail of all bash commands to `hooks/logs/bash-commands.log`
PostToolUse (Edit/Write)	`post-edit-lint.sh`	Runs prettier check on .ts/.tsx/.js/.jsx files
SubagentStop	`log-agent-completion.sh`	Logs agent completions as JSONL
Stop	`enforce-quality-gates.sh`	Logs quality gate checks on session completion

Hook scripts are in .claude/hooks/scripts/. They receive JSON on stdin, exit 0 to pass, exit 2 to block.

Archived YAML hook reference files (non-functional, for design reference only) are in .claude/hooks/reference/.

Agent Infrastructure

All 45 agent .md files use only supported Claude Code frontmatter fields:

Field	Purpose	Valid Values
`name`	Agent identifier	kebab-case string
`description`	Routing description (include “Best for:” and “Not suitable for:“)	Multi-line string
`tools`	Available tools	Comma-separated tool names
`model`	Model selection	`sonnet`, `opus`, `haiku`, `inherit`
`memory`	Persistent cross-session memory	`project`, `user`, `local`
`skills`	Preloaded skill content	Array of skill names
`permissionMode`	Permission handling	`default`, `acceptEdits`, `plan`, `delegate`
`maxTurns`	Execution limit	Integer
`hooks`	Agent-scoped lifecycle hooks	Hook event config
`color`	UI display color	Color name

Self-Management Protocol

Each agent includes a Self-Management Protocol in its markdown body that instructs the agent to follow its own operational config:

Cost awareness - Track progress against token budgets
Retry behavior - Handle tool failures with configured retry strategies
Quality gates - Verify work quality before marking complete
Performance logging - Summarize execution metrics for completion logs

The Agent Operations Config (YAML block in markdown body) contains the operational parameters (cost_budget, retry_strategy, quality_gates, performance_tracking, routing). This is NOT frontmatter — it’s agent instructions that the LLM reads and follows.

Agent Teams

Agent teams are enabled via CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in .claude/settings.json. This allows multi-agent coordination workflows.

Plugin Distribution

The project is packaged as a Claude Code plugin via .claude-plugin/plugin.json for distribution.

Available Skills (32 total: 18 top-level + 14 Obra sub-skills)

Skills can be:

Preloaded into agents via the skills: frontmatter field (explicit)
Auto-activated based on context (Obra Superpowers)
Available on-demand via Skill tool invocation

Currently Preloaded in Agents

Skill	Used By
`frontend-design`	implementer
`qa-architect`	implementer, implementation-verifier, full-stack-verifier, qa-engineer
`brand-voice`	content-creator
`content-optimizer`	content-creator, seo-optimizer, ai-search-specialist
`security-auditor`	security-auditor
`infra-as-code`	devops-engineer
`vps-ops`	devops-engineer
`release-manager`	rollout-coordinator, rollback-sentinel

Available On-Demand (13)

compliance-mapper, data-governance, onprem-ops
stripe-revenue-analyzer, vercel-landing-page-builder
ai-sdk, vercel-composition-patterns, vercel-react-best-practices, vercel-react-native-skills, web-design-guidelines
Obra Superpowers (14 auto-activated skills in .claude/skills/obra-superpowers/)

Claude Configuration Reference

Contents

Prompt Blueprint - Claude Code Configuration

Project Overview

Core Philosophy

Data Model Enhancement

Zoho ONE Integration Priority

Slash Command Usage

Compound Engineering Workflow Commands (NEW)

DEVB (Design-Emulate-Validate-Build) System Commands

Design OS Commands (Product Planning & UI Design)

Prompt Engineering Commands

Zoho Operations Commands

Agent Coordination Commands

Workflow Commands

Agent OS Commands (Spec-Driven Development)

Agent Routing Guidelines

When to Use Which Agent

Approval Workflows

Compound Engineering System

Philosophy: 80/20 Planning vs. Execution

Two Workflow Types

1. ArchitectFlow (Upfront Planning)

2. DevFlow (In-Sprint Reviews)

Multi-Agent Parallel Reviews

1. Security Agent

2. Performance Agent

3. Architecture Agent

4. Testing Agent

Knowledge Compounding

Learning Categories

Impact Scoring (1-10)

Automatic Integration

Search and Retrieval

Database Schema

Workflow Sessions

Review Sessions

Compound Learnings

API Endpoints

Example Usage

Available Skills

Original Skills (13)

Vercel Skills (5 new)

Obra Superpowers (14 new - auto-activated based on context)

Comprehensive Slash Commands

Quick Access by Category

Resource References

DEVB System Documentation

Guides (Best Practices)

Meta-Prompts (Agent Definitions)

Examples (Templates)

Patterns (Integration Strategies)

Templates (Reusable Agents)

Development Workflow

Adding New Functionality

Creating New Slash Commands

Creating New Agents

Quality Standards

All Prompts Must:

All Integrations Must:

All Slash Commands Must:

Troubleshooting

Command Not Working?

Agent Not Behaving Correctly?

Zoho Integration Issues?

Important Notes

Claude Code Infrastructure (v3.0)

Hook System

Agent Infrastructure

Self-Management Protocol

Agent Teams

Plugin Distribution

Available Skills (32 total: 18 top-level + 14 Obra sub-skills)

Currently Preloaded in Agents

Available On-Demand (13)