Skip to content
Skills Library
Programming · Automation

pm-developer

/pm-developer

Runs the pm-cli developer execution loop (orient, claim, implement, verify, close) with linked files/tests/docs evidence, under an explicit token budget. Use when coding, debugging, refactoring, or shipping repository changes tracked in pm items.

Repository
pm-cli ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
7
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Runs the pm-cli developer execution loop (orient, claim, implement, verify, close) with linked files/tests/docs evidence, under an explicit token budget. Use when coding, debugging, refactoring, or shipping repository changes tracked in pm items.

Original author description

Runs the pm-cli developer execution loop (orient, claim, implement, verify, close) with linked files/tests/docs evidence, under an explicit token budget. Use when coding, debugging, refactoring, or shipping repository changes tracked in pm items.

How it works

  1. Load Order
  2. Non-Negotiables
  3. Canonical Loop
  4. Capability Map
  5. Token Discipline
  6. Verification Defaults
  7. References
Original SKILL.md headings · 122 lines, 756 words
SKILL.md preview
---
name: pm-developer
description: Runs the pm-cli developer execution loop (orient, claim, implement, verify, close) with linked files/tests/docs evidence, under an explicit token budget. Use when coding, debugging, refactoring, or shipping repository changes tracked in pm items.
license: MIT
compatibility: Works in terminal-based coding agents with bash, Node.js, and pnpm.
metadata:
  owner: unbrained
  domain: pm-cli
  scope: developer-workflow
---

# pm Developer Skill

Implementation work that changes code, docs, tests, or release gates. `pm` is the
system of record: every change is linked to an item, and every mutation is
recorded in an append-only history stream.

## Load Order

Load only the tier the task needs. Costs are measured, not estimated.

| Tier | Load                                          | Cost      | When                                     |
| ---- | --------------------------------------------- | --------- | ---------------------------------------- |
| 0    | This file                                     | ~650 tok  | Always.                                  |
| 1    | `pm next` or `pm context --limit 10`          | ~2.1-2.5k | Pick or resume work.                     |
| 2    | `pm contracts --command <cmd> --flags-only`   | ~1-3.4k   | Exact flags for one command.             |
| 2    | `pm guide <topic> --depth brief`              | ~0.6-1k   | A capability family you have not used.   |
| 3    | `references/*.md` below                       | ~0.3-1k   | Repeatable procedure detail.             |
| 4    | `docs/*.md`                                   | 0.7k-45k  | Only when a reference routes you there.  |

Never load `docs/COMMANDS.md` (~29k) or `docs/SDK.md` (~45k) whole. Both are
routed into by section from the references below.

Optional deep routing that never goes stale:

```bash
pm package install guide-shell --project
pm guide workflows --depth brief
```

## Non-Negotiables

- Author identity is detected automatically. **Never pass `--author` and never
  set `PM_AUTHOR`.** Supported harness signals can supply model, effort, role,
  and topic. Missing observations remain unknown; do not infer them from a
  configured default or invent provenance for historical entries.
- Never edit files under `.agents/pm` directly. Every mutation goes through `pm`.
- Never claim an item's state from memory. Read it live before asserting it.
- Claim before substantial edits; release when paused, handed off, or closed.
- Search before creating. Record the duplicate check as a create-time comment.

## Canonical Loop

```bash
pm next                                   # or: pm context --limit 10
pm search "<task keywords>" --limit 10
pm claim <ID>
pm update <ID> --status in_progress --message "Start implementation"
# ...implement...
pm files <ID> --add path=<path>,scope=project,note="<why>"
pm docs  <ID> --add path=<doc>,scope=project,note="<why>"
pm test  <ID> --add command="node scripts/run-tests.mjs test -- <target>",scope=project,timeout_seconds=240
pm comments <ID> "Evidence: <what changed and what passed>"
pm learnings <ID> --add "<lesson that outlives this item>"
pm test <ID> --run --progress
pm close <ID> "<reason with evidence>" --resolution "<delivered change>" --expected "<required outcome>" --actual "<observed outcome>" --validate-close warn
pm release <ID>
```

Before closing a repository defect, inspect its declared `escape_class` and
`gate_evidence` contract and record the required structured evidence. In pm-cli,
follow [Defect Evidence](../../../docs/DEFECT_RECURRENCE.md#defect-evidence-on-pm-items)
and run `pnpm quality:defect-evidence` **after** closure: a gate run while the item
is active cannot prove terminal-only requirements. Verify runner changes with
both build-enabled and prebuilt CI environments.

## Capability Map

Capability families and their commands are generated from the public SDK
contract. Start with `pm guide capabilities`, expand only the family the task
enters, and use these drift-gated references:

- [Capability routing](../../../docs/generated/AGENT_CAPABILITY_ROUTING.md)
- [Visibility tiers and families](../../../docs/generated/AGENT_COMMAND_SURFACE.md)

`pm help` shows the bounded core tier. Use `pm guide capabilities`, `pm
contracts --summary`, or `pm <command> --help --json` for progressive
disclosure into the wider surface. Durable lessons and history maintenance
(`pm learnings`, `pm history <ID> --verify`, `history-repair`, `history-redact`,
`history-compact`, `close-many`) are routed by `pm guide evidence`.

## Token Discipline

Every read declares a default ceiling and degrades deterministically rather
than truncating silently. Choose in this order:

1. **Projection** — ask for fewer fields: `pm get <ID> --output-include id,title,status,dependencies`.
2. **Row limit** — `--output-limit 20`, or the command's own `--limit`.
3. **Budget** — `--output-budget <tokens>` only when the first two are set.
4. **Continuation** — when a response carries `output_budget_truncation`, use
   the declared `--output-cursor`. Re-running with `--output-budget unbounded`
   can cost orders of magnitude more.

Always read the `omission_receipt` before treating a result as complete. See
[Token budgets and read output](references/TOKEN_BUDGETS.md).

## Verification Defaults

For test authoring, review, or cleanup, apply [pm-test-audit](../pm-test-audit/SKILL.md)
to preserve independent contracts while removing low-value duplication.

```bash
pnpm build
node scripts/run-tests.mjs test -- <targets>
node scripts/run-tests.mjs coverage
pm validate --check-resolution --check-history-drift
pm health --summary
```

Repository-wide gates before proposing a merge: `pnpm quality:static`.

## References

| Need                                             | Load                                                     | Cost     |
| ------------------------------------------------ | -------------------------------------------------------- | -------- |
| Command recipes for the developer loop            | [Command playbook](references/COMMAND_PLAYBOOK.md)        | ~275 tok |
| Prompt templates                                  | [Prompts](references/PROMPTS.md)                          | ~250 tok |
| Bounded reads, cursors, projections, receipts     | [Token budgets](references/TOKEN_BUDGETS.md)              | ~900 tok |
| Typed edges, traversal, planning analytics        | [Relationship graph](references/GRAPH_AND_RELATIONSHIPS.md) | ~900 tok |
| Branching, merging, concurrent agents             | [Multi-agent and merge](references/MULTI_AGENT_MERGE.md)  | ~800 tok |
| Composing pm with grep, jq, xargs, and scripts    | [Scripting](references/SCRIPTING_COMPOSITION.md)          | ~800 tok |
Files in this package (7)
  • SKILL.md 7 KB
  • references/COMMAND_PLAYBOOK.md 1 KB
  • references/GRAPH_AND_RELATIONSHIPS.md 5 KB
  • references/MULTI_AGENT_MERGE.md 3 KB
  • references/PROMPTS.md 1 KB
  • references/SCRIPTING_COMPOSITION.md 3 KB
  • references/TOKEN_BUDGETS.md 3 KB

Versions

RepositoryScoreLicence
This page · unbraind/pm-cli100MIT
unbraind/pm-cli86MIT

Database snapshot: 13.11.2026 · package version 656f66f124cd (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100developer-like-execution
    Use when implementing, debugging, refactoring, or reviewing code — enforces the think → analyze → verify → execute workflow — even when the user just says 'implement X' without naming it.
  • 90understand-propose-implement-verify
    Use when following a strict problem-solving loop: understand, propose, implement, verify.
  • 86verify
    Testing and review phase. Runs the project's gates, a developer review of the diff, and a tester pass that exercises the change for real, with evidence and reusable test cases. Use when the user says "verify", "test it", "check it", or "is it ready".
  • 90designing-developer-cli
    Use when designing developer cli is required during developer-tools product work, especially when the result must be traceable, independently reviewable, and safe to hand to another agent.
  • 90senior-software-developer
    Use when developing new features, refactoring code, or implementing production-grade software solutions requiring senior-level expertise

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.