fabrik

Builder that takes requirements and ships code in the lead's worktree.

Team lead that refines ideas into concrete requirements, challenges assumptions, and manages scope.

Read-only observer that surveys active feature worktrees and reports progress back to the user.

QA critic that reviews code and runs automated checks in the lead's worktree.

Address code review feedback by walking through comments one at a time with the user. Use when the user has received code review comments — on a GitHub PR, in a document in the repo, in review.jsonl, or directly in conversation — and wants to work through them methodically. Also trigger when the user mentions "address review", "review comments", "PR feedback", "review.jsonl", or wants to respond to code review feedback.

Guide for building on the AT Protocol (the "atmosphere") -- authoring Lexicons, building app views, consuming the firehose, working with identity (DIDs, handles), repositories, records, XRPC endpoints, and OAuth. Use this skill whenever the user is building anything on atproto/Bluesky/the atmosphere -- writing Lexicon JSON, calling com.atproto.* or app.bsky.* endpoints, parsing AT URIs (`at://...`), DIDs (`did:plc:...`, `did:web:...`), handles, TIDs, the indigo Go SDK (`github.com/bluesky-social/indigo`), the firehose / `subscribeRepos`, MSTs, CAR files, DAG-CBOR/DRISL, app views, feed generators, labelers, or PDS interactions. Triggers even if the user doesn't say "atproto" -- words like "lexicon", "PDS", "app view", "firehose", "did:plc", or `at://` URIs are enough.

Autonomous experiment loop that iteratively improves a measurable metric. Given a goal, a verify command, and an optional guard, the agent branches, makes one change, measures the result, and keeps or discards the experiment -- repeating indefinitely. Use this skill when the user wants to optimize something measurable through automated experimentation, autonomous improvement loops, or when they mention "autoresearch". Works for any domain with a quantifiable metric (code performance, ML training, build size, test scores, content quality metrics, etc.).

Interview the user about a new blog post before writing it. Use this skill whenever the user wants to write a blog post, says "let's write a post about X", "I want to blog about Y", "help me draft a post on Z", or otherwise asks for help producing a blog post. The skill conducts the interview; you write the post afterward based on what you learn.

Guide for posting content to the Bluesky social network using the bsky terminal app. This skill should be used proactively when working in public repositories and there is interesting, shareable content (new features, insights, achievements, or announcements worth sharing with the community). Use it when asked to post to Bluesky, or when content seems worth sharing publicly.

Guide for how to brainstorm an idea and turn it into a fully formed design.

Guide for making code reviews. Use this when asked to make code reviews, or ask to use it before committing changes.

Dispatch a team of two competing reviewers to critique a diff, challenge each other's findings, and produce a high-signal report. Use this when the user asks for a thorough code review, wants a second opinion before committing, or wants findings that have survived adversarial scrutiny. Prefer this over the solo `code-review` skill when rigour matters more than speed. Invoke with /code-reviewers.

Tell the user a dad joke. Use this skill when the user asks for a dad joke, wants to hear something funny, needs cheering up, or says /dad-joke.

Guide for building interactive web UIs with Datastar and gomponents-datastar. Use this skill when adding frontend interactivity to Go web applications with Datastar attributes.

Guide for recording significant architectural and design decisions in docs/decisions.md. Use this skill when clearly significant architectural decisions are made (database choices, frameworks, core design patterns) or when explicitly asked to document a decision. Also suggest proactively at natural session-end moments -- after a PR merges, a feature ships, or a work chunk wraps up -- if a significant decision was made during the session and not yet recorded. Be conservative - only suggest for major decisions, not minor implementation details.

For when you're asked to write a design doc or specification, especially after a brainstorm or feature design session.

Write and maintain an implementation diary capturing what changed, why, what worked, what failed (with exact errors and commands), what was tricky, and how to review and validate. Activates proactively during non-trivial implementation work (new features, bug fixes, refactors, research spikes) and at natural session-end moments -- after a PR merges, a feature ships, or a work chunk wraps up -- to capture the narrative while it's still fresh. Does not activate for trivial tasks like one-line fixes, config tweaks, or quick questions.

Autonomous project gardening. Scans for maintenance issues (starting with documentation), picks one, fixes it in a worktree, self-reviews with competing agents, and opens a PR. Use when the user wants to tidy up the project, fix stale docs, or generally tend the codebase. Invoke with /garden.

Autonomous project gardening by a coordinated team of agents. Spawns a team of gardeners that each run the `garden` skill in parallel, coordinating via a shared task list to avoid duplicate work. Use when the user wants to tend multiple small issues in one pass. Invoke with /gardeners.

Guide for using git with specific preferences -- branch names without `feat/`/`hotfix/` prefixes, backticks around code identifiers in commit messages, asking about GitHub issues to reference before committing. Use this whenever you branch, commit, or write a commit message -- not just when explicitly asked to "commit". These conventions aren't in your default knowledge and you'll get them wrong without consulting this skill.

Guide for how to develop Go apps and modules/libraries. Always use this skill when reading or writing Go code.

Guide for working with gomponents, a pure Go HTML component library. Use this skill when reading or writing gomponents code, or when building HTML views in Go applications.

Review the current conversation for fabrik skills that could be improved (corrections, friction the user had to manually flag, missed triggers, anything else worth flagging) and ship the improvements back to the fabrik repo as a PR (concrete fixes) or issue (fuzzy observations / redesigns). Use when the user invokes /improve-skill or asks to make a skill better, smarter, or less friction-prone. May also be suggested at end of session if there's concrete signal that a skill underperformed; otherwise stay silent.

Guide for creating and working with marimo notebooks, the reactive Python notebook that stores as pure .py files. This skill should be used when creating, editing, running, or deploying marimo notebooks.

Guide for running Python code on Modal, the serverless compute platform for AI workloads, batch jobs, scheduled tasks, web endpoints, and sandboxed code execution. Use this skill whenever the user is writing or modifying Modal code (anything importing `modal`, decorating with `@app.function`, `@app.cls`, `@modal.fastapi_endpoint`, etc.), running `modal run`/`modal deploy`/`modal serve`, configuring GPUs/images/volumes/secrets for Modal, or asking how to host inference, fine-tuning, or agent sandboxes on Modal.

Guide for generating and editing images using generative AI with the nanobanana CLI

Guide for using Observable Plot, a JavaScript library for exploratory data visualization built on D3. Use this skill when creating charts, exploring data, or building visualizations with marks, scales, and transforms.

Guide for saving a web page for offline use using the monolith CLI. Use this when instructed to save a web page.

Perform a thorough security review of the project, starting from a randomly selected file. Use this skill when the user asks for a security review, security audit, vulnerability scan, or wants to check the codebase for security issues. Also trigger when the user mentions "check for vulnerabilities", "find security bugs", "OWASP", or any request related to assessing the security posture of the project.

Write and iterate on a project spec (docs/spec.md) that defines what the product is and why it exists. Use this skill when the user asks to create or update a spec, says "let's spec this out", or when a product decision comes up in conversation that should be captured in the spec. Also use proactively when the user is about to start building something that doesn't have a spec yet.

Guide for working with SQL queries, in particular for SQLite. Use this skill when writing SQL queries, analyzing database schemas, designing migrations, or working with SQLite-related code.

Guide for fine-tuning LLMs, embedding models, vision-language models, and TTS models efficiently with Unsloth. Covers LoRA/QLoRA SFT, reinforcement learning (GRPO, DPO, ORPO, KTO), embedding fine-tuning with sentence-transformers, continued pretraining, and saving/exporting to GGUF, Ollama, or vLLM. Use this skill whenever the user mentions Unsloth, FastLanguageModel, FastSentenceTransformer, FastVisionModel, FastModel, or wants memory-efficient fine-tuning of open LLMs or embedding models on a single GPU, even if they don't explicitly say "Unsloth".

Project-specific worktree setup for applications with services (port allocation, service startup/shutdown). Use alongside Claude Code's built-in worktree support when the project runs web servers, docker-compose, or other services that need unique ports per worktree.

Apply Strunk's timeless writing rules to ANY prose humans will read—documentation, commit messages, error messages, explanations, reports, or UI text. Makes your writing clearer, stronger, and more professional.

1 hook across 1 event