claude

eng

Plan-to-ship engineering pipeline. Six composable skills (scope, grill, eng-review, tdd, execute, ship) plus an orchestrator (eng-flow), each a single pass over a shared markdown doc in the project's .plan folder, with full and express tracks. Standalone skills: research, migrate, resolve-conflicts, conventions (house-style cache every other skill reads), understand, debug, spike, adr, refactor, backfill-tests, pr-walkthrough, pr-review, review.

1 on GitHubby Nitin Panwarv0.8.0updated 10 days ago
/

Plugin eng from marketplace nitin-ai-skills in nitintf/skills. Commands read from the repo's manifest — 8 days ago.

What it installs

Skills (20)

  • adr

    Write an Architecture Decision Record: the forces, the options genuinely considered, the choice, and the consequences you are accepting. Also supersedes an earlier ADR.

  • backfill-tests

    Add tests to existing untested code. Picks a target by risk, reads the code to understand what it actually does, matches the repo's test style, then writes characterization tests that lock in current behavior: covering happy path, edge cases, and error paths. Surfaces suspected bugs instead of silen

  • conventions

    Scan a repo once and cache its house style to `.plan/_conventions.md`, how APIs are defined, how components are structured, error handling, logging, config, naming, the existing test style, and which shared primitives already exist, each with real file:line evidence. Every other eng skill reads this

  • debug

    Systematically root-cause a bug instead of guessing at fixes. Reproduces the failure first, narrows the surface with evidence, forms explicit competing hypotheses and kills them one at a time, confirms the true cause by predicting and observing, then fixes the cause (not the symptom) and locks it wi

  • eng-flow

    Run the whole eng pipeline off the `.plan` doc's phase and track, pausing at a gate between each pass. Resumes wherever you left off.

  • eng-review

    Engineering-manager review of a `.plan` doc: architecture, edge cases, tests, performance, and consistency with how this codebase already builds things. Scores each and folds fixes back in.

  • execute

    Build a fully-planned `.plan` ticket: failing tests first, implement to the acceptance criteria in house style, make them pass, then verify and log the work.

  • grill

    Interview you about a scope doc's open questions, then add its own, and write the answers into the doc's Decisions.

  • migrate

    Plan and run a data or schema migration without losing data. Characterizes the real data first, picks a strategy, writes the rollback before the migration, and verifies with queries rather than hope.

  • pr-review

    Staff/principal-engineer review of a pull request, yours or someone else's. Takes a PR number, URL, branch, or the current branch, reads the commits and diff against the base, pulls extra context from GitHub via `gh` (PR description, CI, existing review threads) and the linked ticket from whichever

  • pr-walkthrough

    Understand a pull request you did not write, before you judge it. Takes a PR number, URL, or branch, pulls the author's stated intent and the linked ticket, then maps how the touched subsystem works TODAY on main so the diff is readable, names a "start here" file and a dependency-ordered reading pat

  • refactor

    Plan and safely execute a behavior-preserving refactor. Establishes a test safety net first (runs existing tests green, adds characterization tests where coverage is thin), learns the house style, plans the change as small atomic steps, then executes step by step keeping tests green the whole way, v

  • research

    Investigate a question against primary sources and return a cited answer. Reads specs, RFCs, official docs, changelogs, and library source rather than blog posts and summaries, weighs each source by trust, and says plainly where the sources disagree or go silent. Every claim carries a link. Can be s

  • resolve-conflicts

    Resolve git merge, rebase, or cherry-pick conflicts hunk by hunk, by tracing what each side was trying to do rather than by picking a side. Reads the commits behind both branches, keeps both intents where they are compatible, flags semantic conflicts that leave no markers, and finishes the operation

  • review

    Fast pre-commit review of your uncommitted working diff, in house style, before you commit. Reads staged + unstaged changes and new files, learns how the codebase already does things, and gives a high-signal gut-check: correctness, consistency with the codebase, obvious security/data issues, leftove

  • scope

    Explore the codebase and turn a task into planning docs in `.plan/`, one per ticket, with real file:line touchpoints, a chosen track, and open questions. Front door of the eng pipeline.

  • ship

    Land finished work: review the diff, split it into atomic commits in the repo's style, push, and open a PR whose body comes from the `.plan` doc.

  • spike

    Timeboxed investigation that ends in a recommendation: evaluate 2-4 approaches against this codebase's real constraints and pick one, with a confidence level.

  • tdd

    Turn a reviewed `.plan` doc's acceptance criteria into a test contract: a unit-test spec plus a manual QA checklist. Specifies tests; does not write code.

  • understand

    Answer a question about a codebase, or map an unfamiliar one, with real file:line evidence. Two modes, auto-detected: QUESTION mode ("how does auth refresh work?", "where is rate limiting enforced?") searches the whole codebase and delivers a sourced answer; MAP mode ("understand this repo", "explai

View source on GitHub

More from nitintf/skills

All 8 plugins →

studio

claude

Find and plan a new product before any code: /ideas finds what to build, /idea runs office hours, /niche researches the category into an interface thesis, /founder-review settles scope, /brand finds a free name and draws the icon, /design-system locks one distinctive design system as tokens, /design-variants and /mockups design every screen as HTML, /design-review scores it and checks drift, /tech-plan fixes the stack, architecture and code rules, /launch-kit writes the store listings, screenshots and landing page. /studio-flow runs them in order.

12 skills

1

Workflow helpers: /ask (the router over every skill in this marketplace), catchup, caveman, handoff, stress-test. The daily work loop moved to the work plugin, and studying is in learn.

5 skills

1

work

claude

The work day loop, one Obsidian note per day. /daily plans the day into a task list from calendar, mail, Slack, Jira and meeting notes, /standup prints a speakable update, /shutdown closes the day from real evidence and commits the vault, /weekly reviews the week. The notes folder comes from 99 Meta/Paths.md in the vault.

4 skills

1

product

claude

Product-thinking skills. Write staff-level PRDs, slice them into testable user stories, or run /product-flow to take an idea through both and hand off to eng's /scope. Output lands in .plan/<feature>/ where /scope reads it directly.

3 skills

1

writing

claude

Plain, direct English for everything Claude writes, plus the tools to write skills. /unslop rewrites or audits text that reads like AI wrote it, /skill authors new skills to this repo's standard, and a SessionStart hook keeps the house style live in every session.

2 skills · hooks

1

learn

claude

A daily study loop for DSA, system design and reading. /study plans today's problems, reading and system design from your tracker, review queue and bookmarks. /study-shutdown logs what you did, schedules problems to come back, moves your reading bookmark and hands what you learned to /note.

2 skills

1

Maintain eng?

This page updates itself from your repo. Add the badge to your README, or get it Featured to pin it above the organic results with a followed link to your site.

claude & codex plugins8 plugins