Skip to content

lasp/adamant-skills / task-planning

task-planning

Verified

Meta-skill for executing complex multi-step tasks under time pressure. Use when a task has 5+ deliverables, a timeout constraint, or risk of getting stuck debugging one issue. Teaches upfront planning, time-boxing, progress tracking, and honest reporting.

FileKindSize
SKILL.mdskill md5.7 KB
---
name: task-planning
description: Meta-skill for executing complex multi-step tasks under time pressure. Use when a task has 5+ deliverables, a timeout constraint, or risk of getting stuck debugging one issue. Teaches upfront planning, time-boxing, progress tracking, and honest reporting.
---

# Task Planning

Execute complex tasks systematically under time constraints. This skill is
about HOW to work, not WHAT to build.

## When to Use

- Task has 5+ discrete deliverables (components, files, tests)
- Session has a timeout (any spawned sub-agent)
- Work is repetitive (build N things following the same pattern)
- Prior attempts timed out or got stuck debugging one item

## Step 1: Inventory (first 2 minutes)

Before writing ANY code, enumerate every deliverable:

```
# Example: "Build 20 components with tests"
PLAN:
- [ ] Component 1: survival_heater_controller (yaml, impl, test)
- [ ] Component 2: temperature_watchdog (yaml, impl, test)
- [ ] ...
- [ ] Component 20: science_thermal_telemetry (yaml, impl, test)
- [ ] admt style --all (all components)
- [ ] admt test --all (all components)
Total: 20 components x 3 files = 60 files + 2 verification steps
```

Write this to a scratch file (`/tmp/task_plan.md`) so you can track progress.

## Step 2: Time Budget

Calculate time per item:

```
Timeout: 30 minutes
Items: 20 components + style + test
Budget: 30 min / 22 items = ~80 seconds each
Reserve: 5 min for unexpected issues
Adjusted: 25 min / 22 items = ~68 seconds each
```

If the math says you can't finish, say so immediately. Propose splitting
the work ("I can do 10 components in this session, need a second session
for the rest").

## Step 3: Execute in Batches

Don't build one component end-to-end then the next. Batch by operation:

**Round 1: All YAML files** (fastest, most mechanical)
- Create all component.yaml, commands.yaml, events.yaml, data_products.yaml
- This is the foundation -- errors here cascade, so get it right

**Round 2: All implementations**
- Write all .ads and .adb files
- Follow the same pattern for each -- don't over-engineer individual components

**Round 3: All test files**
- Create test dirs, env.py, tests.yaml, test implementations
- Use the same test structure for each component

**Round 4: Verify**
- `admt style` on each component
- `admt test` on each component
- Record pass/fail per component

Batching is faster because you stay in the same mental context and can
copy-paste patterns.

## Step 4: Time-Box Problems

When something breaks:

```
IF time_spent_on_this_item > 2x budget:
    Note the error in scratch file
    Move to next item
    Come back IF time remains at the end
```

**Never spend more than 3 minutes debugging a single item.** Note the error
message, skip it, keep building. You can always come back. You can't get
time back.

Common traps:
- Style warning on one file -- note it, fix later in batch
- Compilation error in one component -- might be a typo, note and move on
- Test failure -- record the assertion, move on
- Unfamiliar framework pattern -- read the skill once, apply everywhere, don't research per-component

## Step 5: Progress Checkpoints

Every 5 items (or every 5 minutes), update your scratch file:

```
PROGRESS (12 min elapsed, 18 min remaining):
- [x] Components 1-8: yaml + impl + test done
- [ ] Components 9-20: yaml done, impl in progress
- [!] Component 3: style warning "redundant with clause"
- [ ] Style check: pending
- [ ] Test run: pending
```

This prevents the "where was I?" problem after a long debugging detour.

## Step 6: Report Honestly

When finished (or when time runs out), report:

```
COMPLETED: 18/20 components (yaml + impl + test)
PASSED: style 18/18, test 18/18
INCOMPLETE:
  - Component 3: compilation error "missing semicolon line 42"
  - Component 17: test assertion failure "expected 5, got 0"
SKIPPED: none
TIME: 28 min / 30 min budget
```

**Never claim success if items are incomplete.** The orchestrator needs
accurate information to decide next steps.

## Anti-Patterns

### The Rabbit Hole
Spending 15 minutes debugging one style warning while 19 components
remain unbuilt. **Fix: time-box at 3 minutes, skip and return.**

### The Perfectionist
Writing 6 elaborate tests per component when 2-3 focused tests would
suffice and you have 20 components to build. **Fix: consistent depth
across all items, not deep on some and absent on others.**

### The Silent Timeout
Running out of time without reporting what's done vs what's not.
**Fix: checkpoint every 5 minutes, always end with a status report.**

### The Scope Creep
Adding features not in the spec ("this component should also handle X").
**Fix: build exactly what's asked, note enhancement ideas in the report.**

### The Rewrite Loop
Rebuilding component 1 three times to get it perfect before starting
component 2. **Fix: good enough on first pass, polish in a final pass
if time permits.**

## Template: Scratch File

Create this at session start:

```markdown
# Task Plan
Timeout: {N} minutes
Items: {count}
Budget: {seconds} per item ({minutes} min reserve)

## Deliverables
- [ ] Item 1
- [ ] Item 2
...

## Issues
(note problems here with item name + error message)

## Checkpoints
- {time}: {status}
```

## Scaling Rules

| Items | Strategy |
|-------|----------|
| 1-4   | No planning needed, just build |
| 5-10  | Light planning, batch by type |
| 11-20 | Full planning, strict time-boxing |
| 20+   | Request split into multiple sessions |

## Integration with Other Skills

This skill is a meta-layer. It doesn't replace technical skills -- it
organizes how you apply them:

1. Read task-planning FIRST (this file)
2. Read technical skills (component-dev, testing, etc.)
3. Make your plan
4. Execute using technical skill patterns
5. Track progress per this skill's guidance
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall