Pace
Pace for engineering

Claude tuned for shipping software.

Engineering teams spend half their week on the work between writing code: reviewing PRs, updating standups, diagnosing regressions, writing tests they keep skipping, fixing bugs that show up in prod. Pace gives Claude a disciplined toolkit for each of those moments, plus an opinionated way of working that has held up across enough shipped product to be worth adopting.

Install in Cowork Read the cookbook

thirty-four engineering skills total. See the full catalog →

The way of working

Five skills, one feature, one stack of PRs.

Most engineering work fits a shape: turn an idea into a plan, build the plan as a chain of small reviewable PRs, address review comments, rebase the next PR on top after each merge, reset cleanly between tasks. Pace ships this loop as five skills that compose.

  1. 1

    spec

    Refine a feature into a tracked epic. Walks the idea into a parent issue with ordered sub-issues, each scoped to a single PR. No code yet.

    You say: "Spec the bulk-CSV import. Should handle 50k rows, validate against the user schema, produce a downloadable error report."

  2. 2

    implement

    Build the epic as a stack of PRs. One sub-issue per branch, each stacked on the previous one. Stops cleanly at PR boundaries so you can review before continuing.

    You say: "Implement epic #142. Stop after PR #2 so I can review."

  3. 3

    review

    Address PR comments interactively. Group by file, triage each one as fix-and-reply, decline-with-rationale, or ask-for-clarification. Posts inline replies.

    You say: "Walk me through the review on PR #156. Fix the obvious ones, push back where you disagree."

  4. 4

    topr

    Rebase the next PR after the previous one merged. Correctly drops the commits that came in via squash-and-merge. No duplicate commits, no fighting the rebase tool.

    You say: "PR #156 just merged. Rebase #157 on main."

  5. 5

    next

    Reset between tasks. Clean throwaway branch on the latest main so the next task starts from a known state. Old branch left intact in case you need to come back.

    You say: "Next."

The point is not the names; the point is that the loop is opinionated and continuous. Once your team adopts it, "what does shipping look like here?" stops being a fresh question every Monday.

Beyond the workflow

Skills for the rest of the week.

The other 29 skills cluster around the standard engineering moments. None of them are commands you memorize; they auto-trigger from how you describe what you want.

Pressure-test before you build

  • grill-me: relentless Q&A until every decision branch has an answer.
  • grill-with-docs: same, but anchors against your CONTEXT.md and ADRs.
  • zoom-out: step back from the function you're staring at and see the system around it.

Tests + coverage

  • tdd: red → green → refactor, with commits at each transition.
  • find-missing-tests: survey a module, produce a specific test backlog.
  • e2e-test: full sweep against real dev servers, mocks disabled.

Diagnose + debug

  • diagnose: the disciplined loop for hard bugs and perf regressions.
  • debug: structured session against a specific error or "works in staging" situation.
  • security-review: OWASP top-10 + language-specific footguns, prioritized findings.

Polish + ship

  • careful-review: re-read what you just wrote with fresh eyes, fix what you find.
  • codex-review: structured second opinion via OpenAI Codex; confirmed fixes committed.
  • ship-pr: commit safely, push, open the PR with a real description and test plan.

Every one of these has a full reference page with trigger phrases, examples, and what to expect. See the engineering cookbook or the skill catalog.

Why this and not just Cursor

Pace is a way of working, not a tool.

Claude can already write code. The question for a team is not "can the agent do it" but "is the way we work with the agent disciplined enough that we'd hire someone we trained on it". The stacked-PR loop, the careful-review pass, the bug diagnosis discipline, the test-first habit, these are the moves that compound when a whole team adopts them.

Pace ships those moves as installable skills so your team uses them the same way the same way each time, with the same vocabulary, against the same expectations. Fork the repo, replace the skills with the ones that match how you actually want your team to work, and you have a codified engineering practice you can onboard new hires (or new agents) into.

Adopt this at your team.

We help engineering teams roll Pace out: install + connector setup, command authoring tuned to your repo's conventions, training your team on the stacked-PR loop, and ongoing support as your playbook grows.

Talk to GoldenBerry Read the cookbook