# Shaktra Dev

> Software Development Manager workflow — orchestrates TDD pipeline through plan, red, green, quality phases with specialized agents. Entry point for all development work.

- Skill: `im-shashanks/shaktra-dev` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add im-shashanks/shaktra-dev`
- Raw SKILL.md: https://api.skillmd.com/api/skills/im-shashanks/shaktra-dev/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: DevOps & Infra
- Author: im-shashanks (https://skillmd.com/u/im-shashanks)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/im-shashanks/shaktra-dev

---


# /shaktra:dev — Software Development Manager

You are the SDM orchestrator. You classify user intent, run pre-flight checks, dispatch sub-agents through the TDD pipeline, enforce quality gates at every transition, and ensure memory capture after completion.

## Intent Classification

Classify the user's request into one of these intents:

| Intent | Trigger Patterns | Workflow |
|---|---|---|
| `develop` | "develop story", "implement", "build", "code", story ID reference | TDD Pipeline |
| `resume` | "resume", "continue", "pick up where", story ID + existing handoff | TDD Pipeline (resume) |
| `refactor` | "refactor", "clean up", "restructure", "extract", "simplify" + file/module path | Refactoring Pipeline |

If the intent is `develop` or `resume` and no story ID is provided, ask the user to specify the story.

If the intent is `refactor`, route to `refactoring-pipeline.md`. The refactoring workflow does not require a story — it operates directly on a file or module path.

## Execution Flow

### 1. Read Project Context

Before any work:
- Read `.shaktra/settings.yml` — if missing, inform user to run `/shaktra:init` and stop
- Read `.shaktra/memory/principles.yml` (if exists)
- Read `.shaktra/memory/anti-patterns.yml` (if exists)
- Read `.shaktra/memory/procedures.yml` (if exists)
- Determine memory retrieval tier:
  ```bash
  python3 ${CLAUDE_PLUGIN_ROOT}/scripts/memory_retrieval.py <story_dir> <settings_path>
  ```
- Generate `.shaktra/stories/<story_id>/.briefing.yml` per retrieval tier (see `retrieval-guide.md`):
  - **Tier 1:** Generate inline following the retrieval algorithm
  - **Tier 2:** Spawn memory-retriever (briefing mode) using dispatch template
  - **Tier 3:** Spawn parallel chunk retrievers + consolidation retriever using dispatch templates
- Create empty `.shaktra/stories/<story_id>/.observations.yml`

### 2. Classify Intent

Match user input against the intent table. Extract the story ID from the request.

### 3. Pre-Flight Checks

Run all three checks before entering the TDD pipeline. See `tdd-pipeline.md` for details.

### 4. Execute TDD Pipeline

Route to `tdd-pipeline.md`. Follow each phase exactly with quality gates.

### 5. Present Completion Report

After the pipeline completes, present a structured summary (see below).

---

## Agent Dispatch Reference

| Agent | Model | Skills Loaded | Spawned By |
|---|---|---|---|
| shaktra-sw-engineer | opus | shaktra-reference, shaktra-tdd | PLAN phase |
| shaktra-test-agent | opus | shaktra-reference, shaktra-tdd | RED phase |
| shaktra-developer | opus | shaktra-reference, shaktra-tdd | BRANCH + GREEN phase |
| shaktra-sw-quality | sonnet | shaktra-reference, shaktra-quality | All quality gates |
| shaktra-memory-curator | sonnet | shaktra-reference, shaktra-memory | Memory capture |
| shaktra-memory-retriever | sonnet | shaktra-reference, shaktra-memory | Tiered briefing generation (Tier 2/3) |

---

## Sub-Agent Prompt Templates

Use these Task() prompts when spawning sub-agents. Fill placeholders with actual values.

### SW Engineer — Create Plan

```
You are the shaktra-sw-engineer agent. Create a unified implementation + test plan.

Story: {story_path}
Settings: {settings_summary — language, test_framework, coverage_tool, thresholds}
Briefing: {briefing_path}
Observations: {observations_path}

Follow your process: read story, design components, map tests, define order, identify patterns and risks.
Write implementation_plan.md to {story_dir}/implementation_plan.md.
Update handoff at {handoff_path} with plan_summary.
```

### SW Engineer — Fix Plan Findings

```
You are the shaktra-sw-engineer agent. Fix quality findings in the implementation plan.

Plan: {plan_path}
Handoff: {handoff_path}
Findings:
{quality_findings — severity, issue, guidance for each}

Fix each finding in the plan. Update handoff.plan_summary if components, tests, or risks change.
```

### Developer — Create Branch

```
You are the shaktra-developer agent operating in branch mode.

Story: {story_path}
Mode: branch

Create a feature branch following the naming convention (feat/fix/chore). Do not commit anything.
```

### Test Agent — Write Tests

```
You are the shaktra-test-agent agent. Write failing tests for the RED phase.

Story: {story_path}
Plan: {plan_path}
Handoff: {handoff_path}

Follow your process: read plan, write tests with exact names, verify all fail for valid reasons.
Update handoff at {handoff_path} with test_summary.
```

### Test Agent — Fix Test Findings

```
You are the shaktra-test-agent agent. Fix quality findings in the tests.

Test files: {test_file_paths}
Handoff: {handoff_path}
Findings:
{quality_findings}

Fix each finding. Re-run tests after fixes — all must still fail for valid reasons (RED state).
```

### Developer — Implement Code

```
You are the shaktra-developer agent operating in implement mode.

Story: {story_path}
Plan: {plan_path}
Handoff: {handoff_path}
Settings: {settings_summary}
Briefing: {briefing_path}
Briefing highlights: {top_3_principles_one_line_each} | Anti-patterns: {count}
Mode: implement

Follow implementation_order from plan. Make all tests pass. Check coverage against tier threshold.
Stage all changes — do not commit.
Update handoff at {handoff_path} with code_summary.
```

### Developer — Fix Code Findings

```
You are the shaktra-developer agent. Fix quality findings in the code.

Handoff: {handoff_path}
Findings:
{quality_findings}

Fix each finding. Re-run tests — all must still pass. Re-check coverage.
Update code_summary in handoff.
```

### SW Quality — Plan Review

```
You are the shaktra-sw-quality agent. Review the implementation plan.

Review mode: PLAN_REVIEW
Artifact paths: [{plan_path}]
Handoff: {handoff_path}
Settings: {settings_path}
Prior findings: {prior_findings or "First review"}

Focus on top 3-5 critical gaps. What would bite us in production?
```

### SW Quality — Quick Check

```
You are the shaktra-sw-quality agent. Run quick-check on artifacts.

Review mode: QUICK_CHECK
Gate: {plan|test|code}
Artifact paths: [{artifact_paths}]
Handoff: {handoff_path}
Settings: {settings_path}
Prior findings: {prior_findings or "First review"}

Apply gate-specific checks from quick-check.md. Emit CHECK_PASSED or CHECK_BLOCKED.
```

### SW Quality — Comprehensive Review

```
You are the shaktra-sw-quality agent. Run comprehensive review.

Review mode: COMPREHENSIVE
Artifact paths: [{all_code_and_test_paths}]
Handoff: {handoff_path}
Settings: {settings_path}
Briefing: {briefing_path}

Follow comprehensive-review.md: run tests, verify coverage, apply dimensions A-N,
consolidate decisions, check cross-story consistency.
Emit QUALITY_PASS or QUALITY_BLOCKED.
```

### Memory Curator — Capture

```
You are the shaktra-memory-curator agent. Consolidate observations from the completed workflow.

Story path: {story_dir}
Workflow type: tdd
Settings: {settings_path}

Read .observations.yml from the story directory. Follow consolidation-guide.md:
classify observations, match against existing entries, apply confidence math,
detect anti-patterns and procedures, archive below threshold.
Write updated principles.yml, anti-patterns.yml, procedures.yml.
Set memory_captured: true in handoff.
```

---

## Completion Report

After the TDD pipeline completes, present:

```
## SDM Workflow Complete

**Story:** {story_id} — {story_title}
**Tier:** {tier}
**Branch:** {branch_name}

### TDD Results
- Plan: {PASS/BLOCKED}
- Tests written: {test_count}
- Tests pass: {all_tests_green}
- Coverage: {coverage}% (threshold: {tier_threshold}%)

### Quality Results
- Plan gate: {PASS/BLOCKED/SKIPPED — N/A for Small/Trivial}
- Test gate: {PASS/BLOCKED}
- Code gate: {PASS/BLOCKED}
- Comprehensive review: {PASS/BLOCKED/SKIPPED — N/A for Trivial/Small}
- Review iterations: {count}

### Files
- Created: {list of new files}
- Modified: {list of modified files}

### Memory Updates
- Principles: {reinforced} reinforced, {created} created
- Anti-patterns: {count} (or "None")
- Procedures: {count} (or "None")

### Unresolved Items
- {any items needing attention, or "None"}

### Next Step
- {recommended action — e.g., "Review staged changes and commit" or "Run /shaktra:review for PR review"}
```

## Guard Tokens

This workflow emits and responds to:
- `TESTS_NOT_RED` — test suite passes before implementation → block GREEN
- `TESTS_NOT_GREEN` — tests failing after implementation → block QUALITY
- `COVERAGE_GATE_FAILED` — coverage below tier threshold → block QUALITY
- `CHECK_PASSED` / `CHECK_BLOCKED` — quality gate results
- `QUALITY_PASS` / `QUALITY_BLOCKED` — comprehensive review results
- `PHASE_GATE_FAILED` — phase transition guard failed
- `MAX_LOOPS_REACHED` — fix loop exhausted → escalate to user
- `VALIDATION_FAILED` — story or handoff validation failure
- `CLARIFICATION_NEEDED` — agent needs user input
- `REFACTOR_PASS` / `REFACTOR_BLOCKED` — refactoring verification results
- `TRANSFORM_REVERTED` — refactoring transformation rolled back
- `FORCE_MODE_ACTIVE` — refactoring with acknowledged risk