# Drafti Architect

> >

- **Type:** Skill
- **Install:** `agentstack add skill-jazz1x-harnish-drafti-architect`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [jazz1x](https://agentstack.voostack.com/s/jazz1x)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [jazz1x](https://github.com/jazz1x)
- **Source:** https://github.com/jazz1x/harnish/tree/main/skills/drafti-architect
- **Website:** https://skills.sh/jazz1x/harnish

## Install

```sh
agentstack add skill-jazz1x-harnish-drafti-architect
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# drafti-architect — Technical Design PRD

> Makes design decisions from technical problems and produces an implementation-ready PRD, without a planning document.

## Bash Convention

Each Bash tool invocation is a fresh subshell. Every bash block re-declares `HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"` inline; no persistent variables.

## Skill Chain

Can be invoked independently. Follow-up: "start implementation after review" → impl, or "/galmuri:ralphi to verify PRD consistency" → galmuri:ralphi (sibling plugin).

## Step 1: Problem Clarification

Inspect 5 items from the user input. Skip items that already have answers.

| # | Item | Inspection Criteria |
|---|------|----------|
| 1 | Problem Definition | Is there a "what is the problem" + specific pain point? |
| 2 | Urgency | Is there a "why must this be solved now"? |
| 3 | Technical Constraints | Are there stack/compatibility requirements? (If none, proceed with "no constraints") |
| 4 | Scope | Is there a distinction between "what to do now" vs "what to do later"? |
| 5 | Success Criteria | Is there a method to determine completion? |

- Only ask about items marked ❌. Skip items marked ✅.
- **Ask 1~2 items at a time, complete within 2 rounds total.** Mark unanswered items as "[unconfirmed]" and proceed.

## Step 2: Existing Asset Query

Extract 3~5 tags from the problem (tech stack → problem domain → task type order).

```bash
HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
if [[ -n "$HARNISH_ROOT" ]]; then
  bash "$HARNISH_ROOT/scripts/query-assets.sh" \
    --tags "{extracted tags}" --format inject \
    --base-dir "$(pwd)/.harnish"
fi
```

- Assets found → reflect guardrails in §7, decisions in §2 reinforcement, failures in §5
- Empty result → proceed without assets

## Step 3: Design Alternative Exploration

**Generate at least 2 alternatives.** Create alternatives even if there is an "obvious right answer."

Alternative discovery: Existing tools? Build from scratch? Architecture change? Status quo? Phased approach?

For each alternative:
```
## Alternative {A/B/C}: {name}
| Aspect | Evaluation |
|------|------|
| Pros | (quantify if possible) |
| Cons | (cost, risk, limitations) |
| Implementation difficulty | Low/Medium/High + reason |
| Suitable situation | When is this the best choice |
| Rejection condition | When should this NOT be used |
```

Details: `references/design-decision.md`

## Step 4: Selection + PRD Writing

### Selection Rationale — must be conditional:

Bad example: "A is better"
Good example: "Team has 2 years React experience + 80% existing code → zero learning cost. Vue requires 3 weeks of learning. Therefore React."

Required: State current situation → what the selection gains → **validity conditions** ("revisit if this condition changes")

### PRD Scale Assessment → Section Decision

| Scale | Criteria | Required Sections | Optional |
|------|------|----------|------|
| Small (1~2 days) |  "PRD draft ready: §{sections} / {scale}. Save to `docs/prd-{slug}.md`? (y / n / edit-slug)"
>
> **If `docs/prd-{slug}.md` already exists**, the prompt becomes: *"`docs/prd-{slug}.md` already exists. (overwrite / n / new-slug)"* — `y` is **not** offered. Treat `overwrite` as explicit destructive confirmation.

- `n` → end. PRD not saved.
- `edit-slug` → ask for slug, then `y` (re-check existence after slug change).
- `y` → proceed with save below.
- `overwrite` → existing file is replaced without backup (user has explicitly confirmed destructive write).
- `new-slug` → ask for a different slug, then re-check existence; repeat until a free slug is chosen or user picks `n`/`overwrite`.

Save PRD (only after `y` or `overwrite`):
```bash
mkdir -p docs/
# Write PRD content to docs/prd-{slug}.md
```

Asset recording (harnish ecosystem mode):
```bash
HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
if [[ -n "$HARNISH_ROOT" ]]; then
  # Decision recording
  bash "$HARNISH_ROOT/scripts/record-asset.sh" \
    --type decision --tags "{tags}" \
    --title "{one-line decision}" --content "{selection rationale}" \
    --base-dir "$(pwd)/.harnish"

  # Guardrail recording (when derived constraints exist)
  bash "$HARNISH_ROOT/scripts/record-asset.sh" \
    --type guardrail --tags "{tags}" \
    --title "{one-line rule}" --content "{consequence of violation}" \
    --base-dir "$(pwd)/.harnish"
fi
```

## Step 6: Completion

```
✅ PRD complete: docs/prd-{slug}.md
Includes: §4 Implementation spec / §6 Test criteria / §7 Guardrails
Next: "start implementation" after review, or /galmuri:ralphi for consistency check.
```

## Distinction from drafti-feature

| User Request | Judgment | Skill |
|-----------|------|------|
| "Create PRD based on this planning doc" | Planning document exists | → drafti-feature |
| "How should I design this problem" | No planning doc, design decision needed | → drafti-architect |

Decide based on presence/absence of a planning document. If uncertain, ask the user "Do you have a planning document?"

## Context Budget

| When | Reads |
|---|---|
| Step 1 (Clarification) | User input only |
| Step 2 (Asset query) | `.harnish/assets/*.jsonl` filtered by tags. Skip if `.harnish/` absent. |
| Step 3 (Alternatives) | `references/design-decision.md` |
| Step 4 (Selection + PRD) | `references/prd-template.md` |
| Step 5 (Save + record) | None (writes only — `docs/prd-*.md` and `.harnish/assets/*.jsonl`) |

Load **at most 1** reference at a time; switch when moving phase.

## Prohibited

- Finishing with only 1 alternative (minimum 2)
- Groundless selection like "~is better"
- Finalizing a decision without validity conditions
- Saving PRD without explicit user confirmation in Step 5
- Saving over an existing `docs/prd-*.md` without explicit `overwrite` confirmation
- Silently assuming PRD scale when unclear
- Loading 2 references simultaneously

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [jazz1x](https://github.com/jazz1x)
- **Source:** [jazz1x/harnish](https://github.com/jazz1x/harnish)
- **License:** MIT
- **Homepage:** https://skills.sh/jazz1x/harnish

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-jazz1x-harnish-drafti-architect
- Seller: https://agentstack.voostack.com/s/jazz1x
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.