nicolas-codemate/aep

AEP Skill - Analyse, Explore, Plan

This skill defines the methodology for thorough analysis and planning before any development work. It conditions all future context and decisions.

Overview

AEP is a three-phase workflow designed to ensure deep understanding before implementation:

1. Analyse - Understand what the user really needs
2. Explore - Investigate the codebase thoroughly
3. Plan - Create a detailed implementation strategy

Phase 1: ANALYSE

Deeply analyze the user's request by answering these questions:

Core Understanding

• What is the core problem or need?
• What are the implicit requirements not explicitly stated?
• What constraints can be inferred from the context?
• What is the expected outcome or deliverable?

Intent vs Literal

Think carefully about what the user really wants vs what they literally said. Often the literal request is a symptom of a deeper need.

Success Criteria

• How will we know the implementation is successful?
• What are the acceptance criteria?

Phase 2: EXPLORE

Launch up to 3 Explore agents IN PARALLEL to thoroughly investigate the codebase:

Agent 1: Existing Implementation

Search for:

• Similar patterns already in the codebase
• Related code that might be affected
• Existing solutions that could be reused or extended
• Code that does something similar we can learn from

Tools: Glob, Grep, Read

Agent 2: Dependencies & Architecture

Understand:

• How this fits in the current architecture
• What dependencies exist (imports, services, modules)
• What will be impacted by changes
• Architectural constraints or patterns to follow

Tools: Glob, Grep, Read

Agent 3: Test Patterns

Find:

• How similar features are tested
• Existing test utilities or helpers
• Test coverage expectations
• Integration vs unit test patterns used

Tools: Glob, Grep, Read

Exploration Rules

1. Use tools extensively - Read more code than you think necessary
2. Follow the breadcrumbs - One file often leads to another
3. Check documentation - README, docs/, comments in code
4. Look at recent changes - git log can reveal context
5. Thoroughness > Speed - This phase conditions everything

Phase 3: CLARIFY

Based on analysis and exploration, identify and ask about:

Must-Clarify (blockers)

• Ambiguities that could lead to wrong implementation
• Technical choices that require user decision
• Scope boundaries that are unclear
• Conflicting requirements

Should-Clarify (important)

• Priority between competing approaches
• Performance vs simplicity trade-offs
• Edge cases handling preferences

Rule

Do NOT proceed to planning if you have unresolved questions that could lead to wrong implementation.

Ask questions using clear, specific language. Propose options when possible.

Phase 4: PLAN

IMPORTANT: Before creating the plan, read and apply the Architect skill from ~/.claude/skills/architect/SKILL.md.

The Architect skill provides:

• Phase design checklists (scope, files, dependencies, validation, rollback)
• Plan-level checklists (completeness, ordering, testing, risks)
• Universal patterns (feature flags, strangler fig, safe migrations)
• Anti-patterns to avoid (big bang phases, hidden dependencies, etc.)

Apply Architect Guidelines

1. Read the Architect skill to internalize the principles
2. Design phases following the atomic phase rules (max 3 files, single goal)
3. Order by risk (infrastructure first, migrations last)
4. Run checklists on each phase before finalizing
5. Document architectural decisions when non-obvious choices are made

Plan Structure

Create a detailed implementation plan with:

Context

• Summary of what you understood
• Key findings from exploration
• Assumptions made (if any)

Architectural Decisions (if applicable)

• Non-obvious technical choices
• Options considered and rationale
• Consequences for implementation

Approach

• Chosen technical approach
• Justification for the approach
• Alternatives considered and why rejected

Implementation Phases

For each phase, include:

• Goal: Single, clear objective
• Files: Explicit paths (max 3 per phase)
• Dependencies: What must be done before
• Validation: Concrete command or check
• Commit message: Conventional format

Risks & Mitigations

• What could go wrong
• How to handle each risk
• Fallback strategies

Testing Strategy

• How to validate the implementation
• What tests to write/modify
• Manual verification steps if needed

Output Language

ALL OUTPUT MUST BE IN FRENCH - Questions, analysis, plan, everything communicated to the user must be written in French.

Core Principles

1. Take exploration seriously — this phase conditions everything that follows.
2. Ask questions when something is unclear, rather than guessing.
3. Read more code rather than make assumptions.
4. Think through edge cases and architectural implications before proposing a plan.
5. Document your reasoning so it can be revisited.
6. Use parallel agents for exploration efficiency (up to 3, scoped per area).

Thinking Mode

ULTRATHINK - Use maximum reasoning tokens for this workflow.

This methodology requires deep analysis. Allocate maximum thinking capacity to:

• Thoroughly analyze the request and its implications
• Consider all edge cases and architectural impacts
• Evaluate multiple approaches before choosing one
• Anticipate potential issues and their mitigations