Etak ships three plugins today: discovery, develop, and deliver. Each exposes six user-facing skills. You do not invoke them by name. You describe the move you want to make, and Etak picks the right one. The purpose of this reference is to make the menu legible so you recognize which move fits which moment in your own work.
| Skill | Stance | The move it supports |
|---|---|---|
| orient | Receptive | Think out loud, find your bearings, decide where to go next |
| explore | Generative | See the space, notice gaps, brainstorm possibilities |
| sound | Exploratory | Surface the beliefs an idea is resting on |
| critique | Adversarial | Stress-test an idea from outside perspectives |
| prioritize | Evaluative | Converge on what matters most, given your constraints |
| experiment | Rigorous | Design tests, record results, propagate learning |
The skills are not a linear process. They form a rhythm you move through repeatedly, often in a single conversation.
Explore → Sound → Critique → Prioritize → Experiment → back to Explore.
You diverge (explore), examine the foundations (sound), stress-test from outside (critique), converge (prioritize), and test (experiment). Results feed the next round of generation. The rhythm applies at every level: opportunities, ideas, assumptions. Orient is the home base, the place you return to when you need to take stock before deciding which move is next.
Match the skill to the state of your thinking.
- You have a signal but no structure → orient
- You have structure but need more options → explore
- You have an idea that looks solid and you want to know what it's actually betting on → sound
- You have an idea and want to know what you're missing → critique
- You have too many options and finite time → prioritize
- You have a belief that would be cheaper to test than to build against → experiment
For plugin-level context, see the develop overview.
| Skill | Stance | The move it supports |
|---|---|---|
| survey | Receptive | Home base. Navigate the work graph, see what's ready, blocked, or stalled |
| plan | Structural | Scope validated ideas, decompose into workstreams and epics, sequence milestones |
| spec | Pragmatic | Grounded technical design. Specs and ADRs against the actual codebase |
| assess | Evaluative | Readiness, feasibility, sizing, critique before committing to build |
| test | Rigorous | Strategy-first testing. Plan from ACs, write at the right layer, debug flakes |
| build | Collaborative | The inner loop end to end. TDD pairing, self-review, PR, feedback |
Development is not a linear waterfall. The skills form a loop you return to at every scale.
Plan → spec → assess → build (with test) → back to plan for the next slice.
You scope and sequence (plan), ground the design (spec), stress-test before committing (assess), and implement with care (build with test). When one slice lands, you look at the graph again (survey) and pick the next move. Survey is home base, the place you return to when you need to see the state of the work before choosing what's next.
Match the skill to the state of the work.
- You want to know what's ready to build and what's blocked → survey
- You have a validated idea that needs structure → plan
- You have a story and need to decide how to build it → spec
- You have a story or spec and want to know if it holds up → assess
- You're about to write tests → test
- You're about to write code → build
You rarely need to think this through explicitly. Describe what you want in plain language and the tool will route.
For plugin-level context, see the deliver overview.
| Skill | Stance | The move it supports |
|---|---|---|
| review | Rigorous senior colleague | Self-review your own work, run a structured review on a PR, respond to feedback |
| verify | Adversarial QE | Confirm a story is actually done — walk each AC against the implementation, check coverage |
| ship | Pragmatic release engineer | Diagnose CI failures, fix them, cut releases, draft notes in the user's frame |
| secure | Adversarial security partner | Walk the attack surface a change opens, identify specific threats, propose tests |
| operate | Structural ops partner | Read existing infrastructure before proposing change, preview blast radius |
| docs | Receptive technical writer | Audit drift between code and docs, generate new docs, update existing pages |
Deliver does not have a single rhythm. Each skill maps to a moment that recurs naturally in the engineer's work — review when something's about to push, verify when a story claims done, ship when CI is red or a release is ready, secure when a change opens new attack surface, operate when infrastructure changes, docs when behavior the docs describe has shifted.
- You finished implementing and want to push → review (self-review)
- A PR needs review → review (PR review)
- You want to confirm a story is done → verify
- CI is red or a release is ready → ship
- You want to know what could go wrong if an attacker tried → secure
- You need infrastructure, monitoring, or a runbook → operate
- The docs and the code disagree → docs
- Develop overview — the plugin-level context for the develop skills, including the artifact hierarchy and agents.
- Deliver overview — the plugin-level context for the deliver skills, including how they pair with develop.
- Artifacts reference — the things the discovery skills produce.
- Product-researcher agent — autonomous research that feeds the interactive skills.
- Foundations — why the skills are arranged this way.