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

<quick_start> 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 .codex/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. </quick_start>

<parameters>

<flags> Enable flags (turn ON):

Disable flags (turn OFF):

</flags>

<examples>

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

<outputstructure> When {savemode} = true:

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

.codex/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:**

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}

````

</output_structure>

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

When provided, step-00 will:

1. Locate the task folder in .codex/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. </resume_workflow>

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

</workflow>

<state_variables> Persist throughout all steps:

</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_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:

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>

<saveoutputpattern> 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 {taskid} {stepnum} {stepname} "inprogress"
2. Append findings/outputs to the pre-created step file
3. Run scripts/update-progress.sh {taskid} {stepnum} {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

</saveoutputpattern>

<success_criteria>

• Each step loaded progressively
• All validation checks passing
• Outputs saved if {save_mode} enabled
• Tests passing if {test_mode} enabled
• Clear completion summary provided

</success_criteria>