Files
Claude-Code-Workflow/CLAUDE.md
catlog22 b01140ae33 feat: Complete v1.2 system enhancements and agent coordination improvements
- Update action-planning-agent to use gemini-wrapper for improved CLI analysis
- Enhance task execution with simplified control structure and context requirements
- Improve plan-deep command with input validation and clarity requirements
- Add intelligent context acquisition rules to CLAUDE.md with required analysis patterns
- Strengthen agent workflow coordination with TodoWrite management and context rules
- Remove deprecated execution controls and streamline task execution flow

System now enforces proper context gathering before implementation and provides
better coordination between agents through structured TODO management.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-09-14 11:22:41 +08:00

85 lines
2.8 KiB
Markdown

# Development Guidelines
## Overview
This document defines project-specific coding standards and development principles.
### CLI Tool Context Protocols
For all CLI tool usage, command syntax, and integration guidelines:
- **Gemini (Analysis)**: @~/.claude/workflows/gemini-unified.md
- **Codex (Analysis)**: @~/.claude/workflows/codex-unified.md
### Intelligent Context Acquisition
**Core Rule**: No task execution without sufficient context. Must gather project understanding before implementation.
**Context Tools**:
- **Structure**: Bash(~/.claude/scripts/get_modules_by_depth.sh) for project hierarchy
- **Module Analysis**: Bash(cd [module] && ~/.claude/scripts/gemini-wrapper -p "analyze patterns")
- **Full Analysis**:
Bash(cd [module] && ~/.claude/scripts/gemini-wrapper -p "analyze [scope] architecture")
Bash(codex --full-auto exec "analyze [scope] architecture")
**Context Requirements**:
- Identify 3+ existing similar patterns before implementation
- Map dependencies and integration points
- Understand testing framework and coding conventions
- Use Task agents for parallel context gathering when needed
## Philosophy
### Core Beliefs
- **Incremental progress over big bangs** - Small changes that compile and pass tests
- **Learning from existing code** - Study and plan before implementing
- **Pragmatic over dogmatic** - Adapt to project reality
- **Clear intent over clever code** - Be boring and obvious
### Simplicity Means
- Single responsibility per function/class
- Avoid premature abstractions
- No clever tricks - choose the boring solution
- If you need to explain it, it's too complex
## Project Integration
### Learning the Codebase
- Find 3 similar features/components
- Identify common patterns and conventions
- Use same libraries/utilities when possible
- Follow existing test patterns
### Tooling
- Use project's existing build system
- Use project's test framework
- Use project's formatter/linter settings
- Don't introduce new tools without strong justification
## Important Reminders
**NEVER**:
- Make assumptions - verify with existing code
**ALWAYS**:
- Plan complex tasks thoroughly before implementation
- Generate task decomposition for multi-module work (>3 modules or >5 subtasks)
- Track progress using TODO checklists for complex tasks
- Validate planning documents before starting development
- Commit working code incrementally
- Update plan documentation and progress tracking as you go
- Learn from existing implementations
- Stop after 3 failed attempts and reassess
#### **Content Uniqueness Rules**
- **Each layer owns its abstraction level** - no content sharing between layers
- **Reference, don't duplicate** - point to other layers, never copy content
- **Maintain perspective** - each layer sees the system at its appropriate scale
- **Avoid implementation creep** - higher layers stay architectural