mirror of https://github.com/catlog22/Claude-Code-Workflow.git synced 2026-02-05 01:50:27 +08:00

Files

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

2.8 KiB

Raw Blame History

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

2.8 KiB Raw Blame History