--- title: Bootstrapping agent tooling description: Tired of constantly copying skills and other agentic artifacts from repo to repo? Set up a Claude Code plugin marketplace packaging project-agnostic skills and a templating wizard for per-repo bootstrapping. date: 2026-09-29 tags: - ai - agents url: https://skurekjakub.dev/blog/agentic-tooling-bootstrap author: Jakub Skurek --- > Agent instructions: > Take page paths from the index rather than constructing them — guessed paths 404. Links inside this document already point at `.md`; following them, or sending `Accept: text/markdown`, keeps you in Markdown. > When citing this page, use the `url` in its frontmatter — the HTML page; this `.md` address is a rendering of it. > > - [llms.txt](https://skurekjakub.dev/llms.txt) — every page with a Markdown twin, with descriptions. > - [skill.md](https://skurekjakub.dev/skill.md) — how to read this site as an agent. Every time I wanted to bootstrap AI tooling in a new repo, I ran into the same tedious setup loop of copying all the tools, skills, agent definitions, and hooks over from previous projects and then tweaking, or in some cases fully rewriting prompt and skill bodies to suit the project stack and desired workflows. This got old really fast. Once you have a curated bundle of skills, plugins, and other miscellaneous tooling that you want in every project, it's time to start automating. As the first step towards making the process less tedious, I started organizing all tooling into a custom [plugin marketplace](https://code.claude.com/docs/en/plugins/create-marketplace). You can take a look over at `giga-marketplace` ([skurekjakub/giga-marketplace](https://github.com/skurekjakub/giga-marketplace)). For me, it organizes agent tooling into two distinct categories. First are standalone plugins that work anywhere out of the box. The second contains skill templates together with a skill that acts as a setup wizard instructing agents how to install more context-sensitive skills into a repository. With this setup, whenever I need to add baseline AI tooling to a new repo, I add the marketplace via Claude Code and install the desired plugins: ```bash /plugin marketplace add skurekjakub/giga-marketplace ``` If you'd like a short overview of each plugin in my marketplace, see the readme on GitHub. For the rest of this post, I want to focus on the templating approach I chose for some of the skills, and how their setup process works. ## Creating prompts from templates Agents produce better results with focused prompting. You want their instructions to carry facts about one codebase. A review agent that checks code against a particular set of coding conventions, a workflow that always runs specific scripts and doesn't omit stuff like version bumps, a hook that blocks commands that only matter in one repository. At the same time, you want each prompt to still follow a roughly similar structure. Templates give us the ability to combine the general structure, which gets encoded once, with placeholders for project-specific facts. Both are bridged by an installation skill that fills the gaps while setting up the tooling in a repository. The result is a set of ordinary skills, agents and hooks that can be read and committed like any other file in the target repo. ### Templates and their structure A plugin stores a pack of templates, which is a folder of files, stored the way they will appear in the target repository, plus a manifest (`pack.json`) that describes them. The files contain custom templating syntax that allows for repo-specific personalization, such as: - `{{VERIFY_CMD}}` or `{{DEFAULT_BRANCH}}` value placeholders that are replaced with the project's own value. This works in paths as well, so `{{AI_DIR}}/reminders.md` ends up wherever the project keeps its agent files. - Lines between `@if` and `@endif` condition markers that are kept only when their condition holds. The markers are written as comments, so the same syntax works in Markdown, shell scripts and YAML. - The manifest `pack.json` can tie a file to an option, and a hook script is then copied only when that hook is selected. A workflow skill in a `dev-workflow` pack, for example, mentions Jira only when the Jira skill is installed alongside it: ```markdown File any Jira issues this needs with the `file-jira-issue` skill. ``` ### Installation steps The installation is handled via a dedicated agent skill that basically turns the agent into a setup wizard. It prompts the agent to ask determine installation parameters, oversee the process, and relay results. Once it gathers all the information, it prepares the data into a structured format for an installation script that renders the templates into actual artifacts in the target repository. ![The developer answers the wizard skill, which passes values to the engine and reads back its report. The engine combines those values with the template pack, writes rendered files and merged config into the repository, and stores the values and file hashes in setup-ai.json. Update and remove read that record back into the engine.](https://skurekjakub.dev/blog/agentic-tooling-bootstrap/template-install.drawio.svg) _Templates to artifacts data flow\._ ## Example - scaffolding with setup-ai In my marketplace, this approach lives in the `setup-ai` plugin. The wizard is its `bootstrap-agent-workspace` skill, and the engine is a script bundled with the plugin (`scripts/workspace.mjs`). Installing and starting it takes two commands inside Claude Code: ```bash /plugin install setup-ai@giga-marketplace /setup-ai:bootstrap-agent-workspace ``` The skill itself then offers a bunch of packs to install: - `baseline` -- working rules for agents, imported from `CLAUDE.md`, plus pull request guidelines. - `review-agents` -- adversarial review subagents, set up against a stack profile for the repository, with starter convention docs. - `dev-workflow` -- phased workflows for features, bugfixes, refactoring and read-only analysis, with journals and review gates. - `issue-tracking` -- ticket filing for Jira through the [jira-mcp](https://github.com/skurekjakub/jira-mcp) server and for GitHub through `gh`, confirmed with the developer before anything is filed. `test-issue` checks a Jira bugfix against the running app. Each pack can also declare dependencies on other packs or plugins in the marketplace. The installation wizard is instructed to notify the user and ask explicit consent via the `askUser` tool. ## Conclusion Splitting agent tooling into standalone plugins and customizable templates simplifies a bit of the current bootstrapping woes. Universal utilities stay portable and zero-config, while repo-specific rules and hooks adapt to the codebase without imposing hardcoded assumptions. The cost to accept is that template updates are not automatic and that someone has to run `update`, or have an agent run it when the session-start notice says a pack is behind. --- Sources: - [skurekjakub/giga-marketplace](https://github.com/skurekjakub/giga-marketplace) — the marketplace repository and all included plugins - [skurekjakub/jira-mcp](https://github.com/skurekjakub/jira-mcp) — the Jira MCP server used by the issue-tracking pack