agentleFS
felipeJJfelipeJJ/fullStack-pipeline/skills/init-profile/SKILL.md

init-profile

Skill1 starsChanged 42 days agoMITView on GitHub

Use when a project has no .claude/pipeline/profile.json yet and the user wants to adopt the fullStack-pipeline workflow, or when the profile needs to be reconfigured (new area, changed test commands, new thresholds).

1 other project uses a version of this.

Adopted by

Most recently taken up by

  • Other versions1 project uses a version of this.

    Word for word · 0

    None found.

    Edited · 0

    None found.

    Wrote their own version · 1

    1. tlennon-ie/neurodock★ 14same name

    How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.

  • In this repository2 other files it gives its agents.

The file

We split this skill into the rules it gives an agent

1 rule. About 0 are common, 0 are distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈0

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    If local-only registry: add .claude/pipeline/ to .gitignore.

    line 47

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Initialize Pipeline Profile

Creates the per-project contract that makes the pipeline portable: .claude/pipeline/profile.json.

Steps

  1. Detect before asking. Inspect the repo: top-level dirs with their own package.json (candidate areas), test scripts in each package.json, existing ESLint config, existing E2E setup (cypress/playwright dirs). Build a proposed profile from evidence.

1.5. Ensure a CLAUDE.md exists. The pipeline depends on it: plans and agents are only as good as the project context they read. Check the repo root:

  • Missing → tell the user it's a prerequisite and offer (AskUserQuestion): (a) generate it now through a short interview (recommended — use the template below), (b) run Claude Code's /init generator and then trim it to the template's shape, or (c) skip for now — record the gap and warn that plans will be generic until it exists.
  • Present → skim it. If it lacks a product overview, permanent decisions, or a "never" list, suggest (don't impose) filling those gaps.

The "Never" question is mandatory in the interview (and whenever an existing CLAUDE.md has no Never section): ask the user directly, in their own words, which things agents must never do in this project — the one section that cannot be inferred from code, only from the owner. Prime with examples of the genre: "never hard-delete — always soft delete", "never commit/push without my explicit approval", "never install new styling libraries", "never touch production data". Use AskUserQuestion (free text via "Other" is fine) or a direct question; accept one item or many. Record the answers verbatim as bullets under ## Never — don't soften or paraphrase them; their bluntness is what makes agents respect them. These rules are enforced downstream: agents treat them as binding and the reviewer rejects violations.

Template — keep it lean, agents read it whole:

  • Overview: what the product is, who uses it, the 5-line architecture (stack per area, deploy).
  • Domain glossary: terms that mean something specific in this product (the entries a newcomer would get wrong).
  • Permanent decisions: intentional choices an agent must not "fix" (with the why).
  • Never: the hard rules (things that look like improvements but are forbidden).
  • Pointers: links to deeper docs with when-to-read guidance (e.g. "touching payments → read docs/billing.md") — pointers keep CLAUDE.md small while making depth discoverable.
  1. Interview with AskUserQuestion (batch, max 4 per call) only for what detection cannot decide. First question is always the preset — it fills every default below, and the remaining questions only cover the areas and whatever the user wants to deviate:

    PresetIntentDefaults
    strictProduction code, quality firstTDD guard blocking, commit gate blocking, reviewer on the strongest model at every level, per-task branches, conventional commits with task ref, lean lite
    balancedThe battle-tested defaultTDD guard blocking, commit gate blocking, cheap testers / mid devs / strong reviewer on L3+, branch and commit convention asked, lean full
    prototypeExploration, speed firstTDD guard advisory, commit gate advisory, cheapest models everywhere, no branch policy, no commit convention, lean ultra

    Then ask:

    • Which areas exist and their names (backend, frontend, mobile, ...). Areas are dynamic — one, two, or five; never assume a back/front pair.
    • Per area: test command, source globs, test globs (confirm detected values).
    • Model matrix — which model each role (tester/dev/reviewer) uses per level band (1-2, 3-4, 5). Present the preset's suggestion and let the user adjust; inherit means "use the session's model".
    • Which test layer is the pillar (E2E vs integration vs unit) — this steers the tester agents.
    • Complexity thresholds (default: warn 10, error 15, ratchet on).
    • Registry versioned in git or local-only (default: versioned — it survives machine changes and shows in PRs; local-only respects a .gitignore habit).
    • Languages — user interaction language vs code/comment language vs user-facing strings in the product (they often differ; record all three).
  2. Write the files:
    • .claude/pipeline/profile.json (shape below). Do not store the plugin's install path in it: that path is versioned and changes on every plugin update — the SessionStart hook announces it each session instead. When reconfiguring an older profile, drop its obsolete cliPath field.
    • .claude/pipeline/plans/ directory.
    • If local-only registry: add .claude/pipeline/ to .gitignore.
  3. Baseline the complexity. Run node <plugin>/scripts/complexity-check.js --all and show the current distribution. If much of the codebase is already above the error threshold, remind the user the ratchet only gates touched code — no big-bang cleanup required: a changed function may not end above the error threshold unless it already was (and then it may not grow), and a function already in the warn zone may not grow.
  4. Offer (do not impose) adding the complexity rule to the project's own ESLint config so humans and CI see the same signal the reviewer enforces.

Profile shape

{
  "preset": "balanced",
  "areas": {
    "backend": {
      "src": ["backend/src/**"],
      "tests": ["backend/tests/**"],
      "testCommand": "cd backend && npm test",
      "skills": ["backend-rules"],
      "notes": "integration tests are the business-rule layer"
    }
  },
  "testPillar": "e2e",
  "models": {
    "tester":   { "1-2": { "model": "haiku", "effort": "low" }, "3-4": "sonnet", "5": "sonnet" },
    "dev":      { "1-2": "sonnet", "3-4": "sonnet", "5": "opus" },
    "reviewer": { "1-2": "sonnet", "3-4": "opus",   "5": "opus" }
  },
  "prices": null,
  "tdd": { "mode": "strict", "exempt": ["**/*.md", "**/*.json", "**/migrations/**"] },
  "branch": { "perTask": true, "minLevel": 3, "pattern": "feat/task-{id}" },
  "commit": { "mode": "strict", "format": "conventional", "requireTaskRef": true, "language": "en" },
  "rework": { "maxAttempts": 3, "incrementalReview": true },
  "lean": "full",
  "language": { "user": "pt-BR", "code": "en", "productStrings": "pt-BR" },
  "complexity": { "warn": 10, "error": 15 },
  "registry": { "versioned": true }
}

The preset only fills the interview's defaults — the written profile is always fully explicit, so any knob can later be changed by editing the JSON or re-running this skill. tdd.mode and the commit gate accept strict (block), advisory (warn, allow), off. Each area's testCommand must exit non-zero when tests fail — task-cli tdd-red runs it to confirm red.

Matrix cells accept a model name or {"model": ..., "effort": "low|medium|high"} — effort is often a bigger saving than a tier swap for mechanical roles. prices (optional) overrides the CLI's built-in per-Mtok price table used by task-cli report for cost estimation; null keeps the defaults.

lean turns on the lean mode adapted from Ponytail: off (none), lite (the ladder only as options in the discovery questions; devs name lazier alternatives), full (plus a rung per mini-task in the plan, the ladder in dev prompts, an advisory over-engineering gate in review), ultra (plus rung 1 asked for every requirement, and reuse:/delete: review findings reject). Absent = off, so older profiles keep their behavior until it is set.

notes per area is free text injected into tester/dev prompts — use it for short stack conventions ("CommonJS only", "TailwindCSS only").

skills per area is the extension point: names of project or user skills (.claude/skills/<name>/ or ~/.claude/skills/<name>/) that pipeline agents must load before working — the place for code-rules skills, security checklists, domain conventions. During detection (step 1), list the project's existing skills and offer to link the relevant ones to each area. This keeps the boundary clean: the plugin carries the process, the project carries the conventions, and the profile says where to find them.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.