<quick_start> Basic usage:

/apex add authentication middleware

Recommended workflow (autonomous with save):

/apex -a -s implement user registration

Flags:

• -a (auto): Skip confirmations

• -s (save): Save outputs to .claude/output/apex/

• -e (economy): No subagents, save tokens

See <parameters> for complete flag list. </quick_start>

Disable flags (turn OFF):

Short Long Description

-A

--no-auto

Disable auto mode

-S

--no-save

Disable save mode

-E

--no-economy

Disable economy mode

-B

--no-branch

Disable branch mode

Autonomous (skip confirmations)

/apex -a add auth middleware

Save outputs

/apex -a -s 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

00-context.md structure:

# APEX Task: {task_id}

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

## Flags
- Auto mode: {auto_mode}
- Save mode: {save_mode}
- Economy mode: {economy_mode}

## User Request
{original user input}

## Acceptance Criteria
- [ ] AC1: {inferred criterion}
- [ ] AC2: {inferred criterion}

</output_structure>

<resume_workflow>
Resume mode (-r {task-id}
):

When provided, step-00 will:

- Locate the task folder in .claude/output/apex/

- Restore state from 00-context.md

- Find the last completed step

- 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
.
</resume_workflow>

<state_variables>
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

{save_mode}

boolean
Save outputs to .claude/output/apex/

{economy_mode}

boolean
No subagents, direct tool usage only

{branch_mode}

boolean
Verify not on main, create branch if needed

{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)

</state_variables>

<entry_point>

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.

</entry_point>

<step_files>
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, validation, and workflow completion

</step_files>

<execution_rules>

- 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.

</execution_rules>

<save_output_pattern>
When {save_mode}
 = true:

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

Each step then:

- Run scripts/update-progress.sh {task_id} {step_num} {step_name} "in_progress"

- Append findings/outputs to the pre-created step file

- 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

</save_output_pattern>

<success_criteria>

- Each step loaded progressively

- All validation checks passing

- Outputs saved if {save_mode}
 enabled

- Clear completion summary provided
</success_criteria>