apex

star 5

Systematic implementation using APEX methodology (Analyze-Plan-Execute-eXamine) with parallel agents, self-validation, and optional adversarial review. Use when implementing features, fixing bugs, or making code changes that benefit from structured workflow.

jyjeanne By jyjeanne schedule Updated 6/9/2026

name: apex description: Systematic implementation using APEX methodology (Analyze-Plan-Execute-eXamine) with parallel agents, self-validation, and optional adversarial review. Use when implementing features, fixing bugs, or making code changes that benefit from structured workflow. argument-hint: "[-a] [-x] [-s] [-t] [-b] [-pr] [-i] [-r ] " metadata: mcpmarket-version: 1.0.0

Execute systematic implementation workflows using the APEX methodology. This skill uses progressive step loading to minimize context usage and supports saving outputs for review and resumption. **Basic usage:**
/apex add authentication middleware

Recommended workflow (autonomous with save):

/apex -a -s implement user registration

With adversarial review:

/apex -a -x -s fix login bug

Flags:

  • -a (auto): Skip confirmations
  • -s (save): Save outputs to .claude/output/apex/
  • -x (examine): Include adversarial code review
  • -t (test): Create and run tests
  • -pr (pull-request): Create PR at end

See <parameters> for complete flag list.

**Enable flags (turn ON):** | Short | Long | Description | |-------|------|-------------| | `-a` | `--auto` | Autonomous mode: skip confirmations, auto-approve plans | | `-x` | `--examine` | Auto-examine mode: proceed to adversarial review | | `-s` | `--save` | Save mode: output each step to `.claude/output/apex/` | | `-t` | `--test` | Test mode: include test creation and runner steps | | `-e` | `--economy` | Economy mode: no subagents, save tokens (for limited plans) | | `-r` | `--resume` | Resume mode: continue from a previous task | | `-b` | `--branch` | Branch mode: verify not on main, create branch if needed | | `-pr` | `--pull-request` | PR mode: create pull request at end (enables -b) | | `-i` | `--interactive` | Interactive mode: configure flags via AskUserQuestion |

Disable flags (turn OFF):

Short Long Description
-A --no-auto Disable auto mode
-X --no-examine Disable examine mode
-S --no-save Disable save mode
-T --no-test Disable test mode
-E --no-economy Disable economy mode
-B --no-branch Disable branch mode
-PR --no-pull-request Disable PR mode
```bash # Basic /apex add auth middleware

Autonomous (skip confirmations)

/apex -a add auth middleware

Save outputs + examine

/apex -a -x -s add auth middleware

Full workflow with tests

/apex -a -x -s -t add auth middleware

With PR creation

/apex -a -pr add auth middleware

Resume previous task

/apex -r 01-auth-middleware /apex -r 01 # Partial match

Economy mode (save tokens)

/apex -e add auth middleware

Interactive flag config

/apex -i add auth middleware

Disable flags (uppercase)

/apex -A add auth middleware # Disable auto

</examples>

<parsing_rules>
**Flag parsing:**

1. Defaults loaded from `steps/step-00-init.md` `<defaults>` section
2. Command-line flags override defaults (enable with lowercase `-x`, disable with uppercase `-X`)
3. Flags removed from input, remainder becomes `{task_description}`
4. Task ID generated as `NN-kebab-case-description`

For detailed parsing algorithm, see `steps/step-00-init.md`.
</parsing_rules>

</parameters>

<output_structure>
**When `{save_mode}` = true:**

All outputs saved to PROJECT directory (where Claude Code is running):

.claude/output/apex/{task-id}/ ├── 00-context.md # Params, user request, timestamp ├── 01-analyze.md # Analysis findings ├── 02-plan.md # Implementation plan ├── 03-execute.md # Execution log ├── 04-validate.md # Validation results ├── 05-examine.md # Review findings (if -x) ├── 06-resolve.md # Resolution log (if -x) ├── 07-tests.md # Test analysis and creation (if --test) ├── 08-run-tests.md # Test runner log (if --test) └── 09-finish.md # Workflow finish and PR creation (if --pull-request)


**00-context.md structure:**
```markdown
# APEX Task: {task_id}

**Created:** {timestamp}
**Task:** {task_description}

## Flags
- Auto mode: {auto_mode}
- Examine mode: {examine_mode}
- Save mode: {save_mode}
- Test mode: {test_mode}

## User Request
{original user input}

## Acceptance Criteria
- [ ] AC1: {inferred criterion}
- [ ] AC2: {inferred criterion}
**Resume mode (`-r {task-id}`):**

When provided, step-00 will:

  1. Locate the task folder in .claude/output/apex/
  2. Restore state from 00-context.md
  3. Find the last completed step
  4. Continue from the next step

Supports partial matching (e.g., -r 01 finds 01-add-auth-middleware).

For implementation details, see steps/step-00-init.md.

**Standard flow:** 1. Parse flags and task description 2. If `-r`: Execute resume workflow 3. If `-s`: Create output folder and 00-context.md 4. Load step-01-analyze.md → gather context 5. Load step-02-plan.md → create strategy 6. Load step-03-execute.md → implement 7. Load step-04-validate.md → verify 8. If `--test`: Load step-07-tests.md → analyze and create tests 9. If `--test`: Load step-08-run-tests.md → run until green 10. If `-x` or user requests: Load step-05-examine.md → adversarial review 11. If findings: Load step-06-resolve.md → fix findings 12. If `-pr`: Load step-09-finish.md → create pull request **Persist throughout all steps:**
Variable Type Description
{task_description} string What to implement (flags removed)
{feature_name} string Kebab-case name without number (e.g., add-auth-middleware)
{task_id} string Full identifier with number (e.g., 01-add-auth-middleware)
{acceptance_criteria} list Success criteria (inferred or explicit)
{auto_mode} boolean Skip confirmations, use recommended options
{examine_mode} boolean Auto-proceed to adversarial review
{save_mode} boolean Save outputs to .claude/output/apex/
{test_mode} boolean Include test steps (07-08)
{economy_mode} boolean No subagents, direct tool usage only
{branch_mode} boolean Verify not on main, create branch if needed
{pr_mode} boolean Create pull request at end
{interactive_mode} boolean Configure flags interactively
{resume_task} string Task ID to resume (if -r provided)
{output_dir} string Full path to output directory
{branch_name} string Created branch name (if branch_mode)

FIRST ACTION: Load steps/step-00-init.md

Step 00 handles:

  • Flag parsing (-a, -x, -s, -r, --test)
  • Resume mode detection and task lookup
  • Output folder creation (if save_mode)
  • 00-context.md creation (if save_mode)
  • State variable initialization

After initialization, step-00 loads step-01-analyze.md.

**Progressive loading - only load current step:**
Step File Purpose
00 steps/step-00-init.md Parse flags, create output folder, initialize state
01 steps/step-01-analyze.md Smart context gathering with 1-10 parallel agents based on complexity
02 steps/step-02-plan.md File-by-file implementation strategy
03 steps/step-03-execute.md Todo-driven implementation
04 steps/step-04-validate.md Self-check and validation
05 steps/step-05-examine.md Adversarial code review (optional)
06 steps/step-06-resolve.md Finding resolution (optional)
07 steps/step-07-tests.md Test analysis and creation (if --test)
08 steps/step-08-run-tests.md Test runner loop until green (if --test)
09 steps/step-09-finish.md Create pull request (if --pull-request)
  • Load one step at a time - Only load the current step file
  • ULTRA THINK before major decisions
  • Persist state variables across all steps
  • Follow next_step directive at end of each step
  • Save outputs if {save_mode} = true (append to step file)
  • Use parallel agents for independent exploration tasks

🧠 Smart Agent Strategy in Analyze Phase

The analyze phase (step-01) uses adaptive agent launching (unless economy_mode):

Available agents:

  • explore-codebase - Find existing patterns, files, utilities
  • explore-docs - Research library docs (use when unfamiliar with API)
  • websearch - Find approaches, best practices, gotchas

Launch 1-10 agents based on task complexity:

Complexity Agents When
Simple 1-2 Bug fix, small tweak
Medium 2-4 New feature in familiar stack
Complex 4-7 Unfamiliar libraries, integrations
Major 6-10 Multiple systems, many unknowns

BE SMART: Analyze what you actually need before launching. Don't over-launch for simple tasks, don't under-launch for complex ones.

**When `{save_mode}` = true:**

Step-00 runs scripts/setup-templates.sh to initialize all output files from templates/ directory.

Each step then:

  1. Run scripts/update-progress.sh {task_id} {step_num} {step_name} "in_progress"
  2. Append findings/outputs to the pre-created step file
  3. Run scripts/update-progress.sh {task_id} {step_num} {step_name} "complete"

Template system benefits:

  • Reduces token usage by ~75% (1,350 tokens saved per workflow)
  • Templates in templates/ directory (not inline in steps)
  • Scripts handle progress tracking automatically
  • See templates/README.md for details
  • Each step loaded progressively
  • All validation checks passing
  • Outputs saved if {save_mode} enabled
  • Tests passing if {test_mode} enabled
  • Clear completion summary provided
Install via CLI
npx skills add https://github.com/jyjeanne/solidspec --skill apex
Repository Details
star Stars 5
call_split Forks 0
navigation Branch main
article Path SKILL.md
More from Creator