More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Project Bootstrapper: Repo Setup and Tooling

    1

    Sets up a new repo — structure, git hygiene, docs, quality gates, tests, locking, CI — or audits and retrofits an existing one, verified by a fresh-clone run.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Project Bootstrapper: Repo Setup and Tooling

    Project Bootstrapper: Repo Setup and Tooling

    Example session with this skill installed

    Three of us are starting a Python invoice-processing service on GitHub. Set the repo up properly before we write any features — I don't want to retrofit this in six months.

    • Read your context and instructions
    • Compiled the project bootstrapper

    BOOTSTRAP REPORT — produced by applying the skill.

    Path: new project (Step 0). Stack preset: Python — uv for locking, Ruff for lint and format in one tool, pytest, GitHub Actions.

    Structure and hygiene: standard layout (src/, tests/, docs/, scripts/); .gitignore from the Python template, extended with the invoice sample-data directory so real customer PDFs can never be committed by accident; .gitattributes marks generated client code; .editorconfig added; pre-commit runs Ruff format and lint on staged files. .env.example lists the four variables the service will need (document store path, OCR endpoint, log level, environment name), each commented; no real values anywhere in the tree.

    Documentation: README with a three-command quick start (install, copy the env example, run the dev entry point), plus develop and test sections; CONTRIBUTING kept to one page; CHANGELOG started with an Unreleased heading.

    Gates: Ruff and the type checker run identically locally and in CI. Decision point applied: format and lint block merges from day one; the type checker starts informational and ratchets to blocking after a few weeks, so it informs without training the team to bypass it.

    Tests and dependencies: pytest configured with one passing unit example and one integration example against a throwaway database; the full suite runs in seconds, so the "fast test command" rule holds. Lockfile committed; vulnerability audit runs in CI; automated update PRs enabled weekly.

    Pipeline: install, lint, typecheck, test, build on every pull request, blocking merge. No deployment job yet — there is nothing to deploy — but the pipeline is structured so adding one later is a new job, not a rewrite.

    Step 8 verification: cloned fresh into a clean directory and followed the README literally. The quick start failed once — the env example omitted the variable the dev entry point reads first. Fixed in .env.example, re-cloned, passed end to end. That catch is the entire point of Step 8.

    Rubric: 9/10 (documentation 2, pipeline 2, gates 2, structure 2, tests/dependencies 1 — the audit threshold ratchets once the first real tests land).

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Projects pay for setup twice: once when you do it, once when you don't and spend a year working around its absence. This skill front-loads the boring decisions in a fixed order. First it picks the path — greenfield setup, or an audit-first retrofit scored across structure, docs, quality gates, tests, and CI, fixing what's missing before polishing what's weak. Then it runs the protocol: standard layout for the stack, git hygiene from templates (ignore rules, attributes, pre-commit hooks), a documentation skeleton whose README quick start is treated as a contract, formatter/linter/type-checker gates that run identically locally and in CI, test scaffolding with one passing example of each test type, a committed lockfile with vulnerability auditing and automated update PRs, and a merge-blocking CI pipeline. It ends the way most setups don't: by cloning the repo fresh and following the README like a stranger, so a broken quick start is caught on day one instead of by the first new hire. You get stack presets for TypeScript, Python, Rust, and Go, a retrofit audit scorecard, a foundation checklist, and a completeness rubric — plus honest handling for inherited repos with committed secrets, 40-minute test suites, or no CI budget.

    • Presets cover four stacks in depth; other stacks get the same protocol but you supply the standard tool for each gate.
    • It sets up gates and scaffolding, not test coverage — the example tests show the shape, your project still has to write its own.
    • On a retrofit, it will not do the big-bang reformat for you; it sequences tooling and formatting into reviewable steps instead.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 24 days ago

    Permissions

    No special permissions declared or detected

    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    No — that is the retrofit path. The skill audits first, scores the five areas with evidence, and fixes what's missing before polishing what's weak, in pull requests small enough to review.

    The presets deliberately bias to each stack's boring standard tools. Anything unusual needs a justification recorded in the repo; the standard choice needs none.

    Not blindly. The skill gates on a fast example suite and files the slow suite as a known defect with an owner — a gate everyone routes around is worse than an honest informational one.

    New in Workflow Automation