feat: More tools and better definitions for agents and commands

Author: udiedrichsen

.claude/agents/git-content-proofreader.md

@@ -5,7 +5,9 @@ model: inherit
 color: blue
 ---
 
-You are an expert Git Content Proofreader specializing in identifying redundancies, conflicts, and inconsistencies in version-controlled content. Your expertise combines technical Git proficiency with editorial acumen to ensure codebase coherence and quality.
+You are a Git Content Analysis specialist focused on processing Git changes and returning actionable quality insights.
+
+**CORE PRINCIPLE**: Process extensive Git diffs and change history, return focused quality report with specific actionable items (targeting 10-20% of input size as concentrated findings).
 
 ## Core Responsibilities
 
@@ -50,30 +52,31 @@ For each issue identified, you will provide:
 
 ## Output Format
 
-You will structure your findings as:
+**CRITICAL**: Process extensive Git changes and return focused insights (aim for 10-20% of input size as concentrated findings). Always lead with the most actionable findings.
 
 ```
-## Git Content Analysis Report
+## Git Quality Analysis
 
-### Summary
-- Files analyzed: [count]
-- Issues found: [count]
-- Critical issues: [count]
+### 🚨 Critical Issues ([count])
+[Only the most urgent problems requiring immediate action]
 
-### Detailed Findings
+### ⚠️ Moderate Issues ([count])
+[Important but non-blocking problems]
 
-#### [Issue Type]: [Brief Description]
-**File**: [filename]:[line_numbers]
-**Severity**: [Critical/Moderate/Minor]
-**Details**: [Comprehensive explanation]
-**Recommendation**: [Specific action to resolve]
+### Action Items
+1. [Most critical action with file:line]
+2. [Next priority with file:line]
+3. [Additional actions as needed]
 
-### Recommendations Priority
-1. [Most critical action]
-2. [Next priority]
-...
+### Files Analyzed: [count] | Total Issues: [count]
 ```
 
+**Response Guidelines:**
+- Lead with critical findings that could break functionality
+- Provide specific file:line references for all issues
+- Focus on actionable next steps, not explanatory details
+- Omit minor issues unless no higher-priority items exist
+
 ## Quality Assurance Principles
 
 You will:

.claude/commands/code.md

@@ -1,10 +1,29 @@
+---
+tools:
+  - Read
+  - Write
+  - Edit
+  - MultiEdit
+  - Bash
+  - Task
+  - TodoWrite
+description: "Multi-agent feature implementation with comprehensive development workflow"
+category: "development"
+---
+
 ## Usage
 `@code.md <FEATURE_DESCRIPTION>`
 
+## When to Use
+- Implementing new features that require architectural planning
+- Building complex functionality requiring multiple development phases
+- When you need comprehensive implementation with quality validation
+- For features requiring integration with existing codebase patterns
+
 ## Context
 - Feature/functionality to implement: $ARGUMENTS
-- Existing codebase structure and patterns will be referenced using @ file syntax.
-- Project requirements, constraints, and coding standards will be considered.
+- Existing codebase structure and patterns will be referenced using @ file syntax
+- Project requirements, constraints, and coding standards will be considered
 
 ## Your Role
 You are the Development Coordinator directing four coding specialists:
@@ -14,14 +33,23 @@ You are the Development Coordinator directing four coding specialists:
 4. **Code Reviewer** – validates implementation quality and adherence to standards.
 
 ## Process
-1. **Requirements Analysis**: Break down feature requirements and identify technical constraints.
-2. **Implementation Strategy**:
-   - Architect Agent: Design API contracts, data models, and component structure
-   - Implementation Engineer: Write core functionality with proper error handling
-   - Integration Specialist: Ensure compatibility with existing systems and dependencies
-   - Code Reviewer: Validate code quality, security, and performance considerations
-3. **Progressive Development**: Build incrementally with validation at each step.
-4. **Quality Validation**: Ensure code meets standards for maintainability and extensibility.
+1. **Input Validation**: Verify feature description is clear and implementable
+2. **Requirements Analysis**: Break down feature requirements and identify technical constraints
+3. **Agent Coordination**:
+   - **Task Tool**: Delegate complex analysis to specialized agents when needed
+   - **Architect Agent**: Design API contracts, data models, and component structure
+   - **Implementation Engineer**: Write core functionality with proper error handling
+   - **Integration Specialist**: Ensure compatibility with existing systems and dependencies
+   - **Code Reviewer**: Validate code quality, security, and performance considerations
+4. **Progressive Development**: Build incrementally with validation at each step
+5. **Quality Validation**: Ensure code meets standards for maintainability and extensibility
+
+## Error Handling
+Following the [standard command error handling patterns](/commands/#error-handling):
+- **Unclear requirements**: Request specific clarification on feature scope and requirements
+- **Missing dependencies**: Identify and install required dependencies before implementation
+- **Integration conflicts**: Provide alternative approaches or refactoring suggestions  
+- **Quality failures**: Iterate on implementation until standards are met
 
 ## Output Format
 1. **Implementation Plan** – technical approach with component breakdown and dependencies.

docs/.vitepress/config.js

@@ -272,6 +272,7 @@ export default withMermaid(
             text: "Resources",
             items: [
               { text: "Overview", link: "/resources/" },
+              { text: "Tools", link: "/resources/tools" },
               { text: "References", link: "/resources/references" },
             ],
           },

docs/advanced/tools.md

@@ -1,25 +1,24 @@
 # Tool Integration
 
-> **🚧 Work in Progress** - IDE and development tool integration patterns are being documented.
+> **📍 Content Moved** - Tool documentation has been reorganized for better discoverability.
 
-Seamlessly integrate Claude Code with your existing development tools and workflows for enhanced productivity.
+## New Location
 
-## Integration Philosophy
+**All tool documentation has moved to:** **[Resources > Tools](/resources/tools)**
 
-Tool integration in vibe coding isn't about replacing your existing workflow - it's about enhancing it with AI assistance that feels natural and unobtrusive.
+This includes:
+- Community tools (Claude Code Usage Monitor, Claude Wizard, Claudia)
+- Advanced tools (CCPM, Claude Code Templates)
+- Integration guides and setup instructions
+- Tool comparison and selection guidance
 
-## Community Tools
+## Why the Move?
 
-### Open-Source Claude Code Tools
-
-#### [Claude Code Usage Monitor](https://github.com/Maciek-roboblog/Claude-Code-Usage-Monitor)
-Real-time terminal monitoring tool for tracking Claude AI token usage and session limits. Use when you need visibility into token consumption, cost tracking, and want to avoid hitting usage limits during development sessions.
-
-#### [Claude Wizard](https://github.com/moinsen-dev/claude-wizard)
-Interactive CLI for discovering and installing specialized AI agents for Claude Code. Use when you want to extend Claude Code's capabilities with curated agents across engineering, marketing, and design domains.
-
-#### [Claudia](https://github.com/getAsterisk/claudia)
-Desktop GUI application providing visual project management for Claude Code sessions. Use when you prefer a visual interface for managing multiple projects, creating custom agents, and tracking development analytics.
+Tools are now organized under the Resources section to:
+- Improve discoverability and navigation
+- Group related resources together
+- Provide clearer categorization
+- Simplify the advanced techniques section focus
 
 ## Core Integrations
 

docs/agents/index.md

@@ -1,16 +1,19 @@
-# Agents & Subagents
+# Agents & Specialized Agents
 
 Harness the power of specialized AI agents to delegate tasks, maintain context, and create sophisticated collaborative workflows that scale with your development needs.
 
-## Overview
+## Core Philosophy
 
-Claude Code agents are specialized AI assistants that excel at specific domains, tasks, or workflows. They're your expert consultants who understand your codebase, follow your conventions, and deliver consistent, high-quality results.
+Claude Code agents are **context firewalls** - specialized processing units that consume large amounts of information and return focused, actionable insights. They excel at specific domains while reducing cognitive load on developers.
+
+**The Agent Principle**: Agents should process 100% of relevant context but return only 10-20% as concentrated, actionable information.
 
 **Why Use Agents?**
+- **Context Reduction**: Process extensive codebases and return focused insights
 - **Specialization**: Each agent masters specific domains rather than being generalist
 - **Consistency**: Agents apply the same expertise and patterns every time
-- **Scalability**: Delegate complex work while maintaining quality standards
-- **Context Preservation**: Agents remember project patterns and preferences
+- **Scalability**: Delegate complex analysis while maintaining quality standards
+- **Cognitive Load Management**: Handle information processing so you can focus on decision-making
 - **Team Alignment**: Shared agents ensure consistent practices across team members
 
 ## Agent Architecture
@@ -51,7 +54,7 @@ Refactoring, optimization, migration, and technical debt management.
 #### 📚 **Documentation Agents**
 Creating, maintaining, and improving project documentation.
 
-## Subagent Use Cases & Patterns
+## Agent Use Cases & Patterns
 
 ### The Multi-Agent Feature Development Pattern
 
@@ -325,32 +328,94 @@ name: "android-specialist"
 description: "Android native development and Play Store optimization expert"
 ```
 
+## Agent Creation Template
+
+Use this template when creating new agents:
+
+```yaml
+name: "agent-name"
+description: "Single-sentence purpose focused on output, not process"
+instructions: |
+  You are [role] specializing in [domain].
+  
+  CORE PRINCIPLE: Process extensive information, return focused insights.
+  
+  INPUT: [What you expect to receive]
+  PROCESS: [How you analyze the input]  
+  OUTPUT: [Specific format of concise results - aim for 10-20% of input size]
+  
+  FOCUS AREAS:
+  - [Specific concern 1]
+  - [Specific concern 2]
+  - [Specific concern 3]
+  
+  COMMUNICATION STYLE:
+  - Lead with actionable findings
+  - Prioritize critical issues
+  - Provide specific file/line references
+  - Suggest concrete next steps
+  
+tools:
+  - name: "Read"
+  - name: "Grep"
+context_files:
+  - "relevant-project-files.md"
+```
+
+## Agent Anti-Patterns
+
+**❌ Avoid These Common Mistakes:**
+
+### The Verbose Responder
+- **Problem**: Agents that return as much information as they process
+- **Solution**: Always summarize and prioritize findings
+
+### The Generalist Agent  
+- **Problem**: Agents that try to handle multiple unrelated domains
+- **Solution**: Create focused, single-purpose agents
+
+### The Anthropomorphized Assistant
+- **Problem**: Agents with personality or conversational behavior  
+- **Solution**: Focus on processing patterns and consistent output formats
+
+### The Inconsistent Agent Communication
+- **Problem**: Mixing "agent" and "subagent" terminology without clear distinction
+- **Solution**: Use "agent" consistently, specify "specialized agent" when needed for clarity
+
+### The Simple Task Handler
+- **Problem**: Using agents for tasks that don't need context reduction
+- **Solution**: Use agents only when processing complexity exceeds output complexity
+
+### The Inter-Agent Communicator
+- **Problem**: Agents designed to work with other agents
+- **Solution**: Design independent agents with clear handoff points
+
 ## Agent Management Best Practices
 
-### 1. **Scope Limitation** 🎯
-- Give agents specific, well-defined responsibilities
-- Limit tool access to what each agent actually needs
-- Avoid creating "do everything" agents
+### 1. **Single Purpose Design** 🎯
+- Give agents one clear, specific responsibility
+- Limit tool access to exactly what each agent needs
+- Ensure agents can operate independently
 
-### 2. **Context Optimization** 📋
+### 2. **Context Reduction Focus** 📋
+- Train agents to process large inputs and return focused outputs
 - Include relevant documentation in context_files
-- Keep agent instructions focused and actionable
-- Update context as project evolves
+- Measure success by output conciseness and actionability
 
-### 3. **Quality Validation** ✅
+### 3. **Output Standardization** ✅
+- Define clear output formats for consistent results
 - Test agents with real scenarios before team adoption
-- Validate outputs match expected quality standards
-- Iterate on instructions based on actual usage
+- Validate that outputs are actionable, not just informative
 
 ### 4. **Team Coordination** 🤝
 - Share successful agent configurations with team
 - Establish naming conventions for agent organization
-- Document agent capabilities and use cases
+- Document specific use cases and expected outcomes
 
 ### 5. **Evolution Management** 🔄
 - Version control agent configurations
 - Update agents as project patterns change
-- Retire or merge agents that become redundant
+- Retire agents that don't provide sufficient value over simple tasks
 
 ## Integration with Command System
 
@@ -385,4 +450,11 @@ Agents work seamlessly with command workflows:
 - `database-perf`: Query optimization and indexing specialist
 - `infrastructure-perf`: Scaling and resource optimization expert
 
-This agent ecosystem transforms development from individual effort into orchestrated specialist collaboration, delivering higher quality results while maintaining development velocity.
+This agent ecosystem transforms development from individual effort into orchestrated specialist collaboration, delivering higher quality results while maintaining development velocity.
+
+## Quick Setup Resources
+
+Accelerate your agent development:
+
+- **[Claude Code Templates](https://github.com/davila7/claude-code-templates)** - Pre-configured agents for frontend, backend, testing, and specialized domains
+- **[CCPM](/resources/tools#ccpm---claude-code-project-management)** - Parallel agent execution system for complex multi-agent workflows