Skillget

my-tech-lead-flow

agent
Security Audit
Warn
Health Warn
  • No license — Repository has no license file
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Low visibility — Only 5 GitHub stars
Code Pass
  • Code scan — Scanned 12 files during light audit, no dangerous patterns found
Permissions Pass
  • Permissions — No dangerous permissions requested

No AI report is available for this listing yet.

SUMMARY

AI Agent Skills library to facilitate technical lead in a software project

README.md

Claude Code Skills

Personal skill library for Claude Code. The core of this repository is a
technical lead pipeline: a sequence of skills that takes a product idea
from raw user stories all the way to a reviewed, documented, deployable
codebase. Each stage is a skill that reads the artifacts produced by the
previous stage and writes the next one, so the project documentation stays
consistent and every decision is traceable back to an acceptance criterion.

The technical lead pipeline

The pipeline runs in order. Steps 1 and 3 are manual (the human supplies or
edits the source material); every other step is a skill invoked with /<name>.
Step 0 is optional, for projects that start from an idea rather than a written
spec.

Step Stage Skill Produces
0 Discover (optional) product-discovery The step-1 requirements table, elicited by interview, when no user stories or AC exist yet
1 Capture requirements (manual or step 0) A Markdown table of user stories, acceptance criteria, and a sprint breakdown
2 Groom grooming Engineering's gaps before commitment. Two modes: blast every question into a file with recommendations (to take to a BA/PO), or interview the user one question at a time and refine the US/AC from their answers
3 Refine (manual) Edits to the US and AC based on grooming output
4 Format us-ac-formatter docs/business/: user-story.md, sprint-breakdown.md, and per-sprint Gherkin acceptance criteria
5 Specify technical-spec docs/technical-specs/: numbered NN-topic.md files plus _index.md, including ad-hoc trailing specs. Grills on tech stack and tooling first
6 Spec the API api-spec docs/api-specs/: numbered NN-topic.md files plus _index.md, deriving every operation, its inputs/outputs, errors, and access rules from the module definitions and data model, in the project's chosen protocol (REST/GraphQL/gRPC/SOAP)
7 Plan work task-breakdown docs/TASK_BREAKDOWN.md: sprint-by-sprint, role-assigned cards, with frontend/backend wiring as its own owned card. Grills on team shape and scope first
8 Set up project tech-lead-setups The Sprint 0 scaffold: folder structure, architectural patterns, commit hooks, tooling config, and endpoint/page stubs returning mock responses. Grills first, then executes
9 Set standards coding-standard CODING_STANDARD.md and CODE_REVIEW_CHECKLIST.md. Grills on every open rule first
10 Init GitHub project github-project-init Issues from every task card (assigned, labelled, milestoned, in the board Backlog), the Projects v2 Kanban board, dev/test/main branches with protection, issue and PR templates, CI quality and build workflows, dependabot, and a release template
11 Plan deployment deployment-plan DEPLOYMENT_PLAN.md: an operational runbook. Grills on infrastructure first
12 Orient newcomers project-docs README.md, GLOSSARY.md, DEVELOPMENT_SCENARIO_GUIDE.md, ONBOARDING_GUIDE.md
13 Document failures troubleshooting TROUBLESHOOTING.md: symptom-indexed guide, scaffolded from the architecture seams
14 Init agent manual init-claude CLAUDE.md: a dense agent operating manual distilled from the specs, standard, task breakdown, and deployment plan. Grills on the gaps the docs leave open first
15 Build (manual + skills below) The implementation
16 Review code-review A structured PR review against the standards, run in an isolated git worktree

How the stages connect

  • product-discovery (step 0) is the on-ramp when no requirements exist yet: it
    interviews and emits the step-1 table, then hands off to grooming.
  • grooming, us-ac-formatter, and technical-spec all treat docs/business/
    as the product source of truth.
  • technical-spec is the architectural keystone: the tech stack, data model,
    and module boundaries it fixes are what api-spec, task-breakdown,
    tech-lead-setups, coding-standard, and deployment-plan build on.
  • api-spec turns the module definitions and data model into concrete operation
    contracts; task-breakdown and tech-lead-setups cite those contracts when
    carving cards and stubbing endpoints.
  • tech-lead-setups reads the technical specs to build the scaffold that
    coding-standard then describes and code-review enforces.
  • coding-standard writes the two documents that code-review consumes as its
    source of truth.
  • github-project-init turns task-breakdown's cards into GitHub issues on a
    board, and its CI quality gate and PR template reference the coding standard.
  • deployment-plan writes the runbook that troubleshooting references rather
    than duplicates.
  • init-claude runs last, distilling the specs, standard, task breakdown, and
    deployment plan into the CLAUDE.md an agent reads before building.
  • Every doc cross-links its siblings instead of restating their content, so
    facts live in exactly one place.

Supporting skills

General-purpose skills that assist the pipeline at any stage:

  • grill-me, grill-with-docs: stress-test a plan or design before building.
  • diagnose: disciplined debugging loop. Feeds confirmed incidents back into
    troubleshooting.
  • tdd: red-green-refactor build loop.
  • to-prd, to-issues, triage: convert context into tracked work.
  • improve-codebase-architecture, zoom-out, prototype, simplify.
  • git-commit, setup-pre-commit, git-guardrails-claude-code.
  • stop-slop: remove AI writing patterns from prose.
  • handoff, caveman, skill-creator, write-a-skill.

Reviews (0)

No results found