Agent Skills MCP Server

agent-skills

An opinionated development stack for coding agents: you describe what you want, the agent asks only the decisions that are yours, builds it test-first, has it reviewed independently, shows it working, and ships only when you say so.

The stack is a set of skills that call each other, kept in skills/stack/. Next to it, the collection offers standalone skills for engineering, web, and game work that you can install one at a time. These are independent, community-maintained skills, not official vendor products.

The stack · How it works · Get started · Choose by task · Requirements · All skills · Contribute

The stack

Agents fail in predictable ways: they build before understanding the request, ask you what the repository already says, grade their own work, bury you in jargon or in ceremony, and publish without asking. The stack answers each failure with an opinion.

• Understand before building. The agent restates the outcome and how you will both know it works before it changes any code.
• Facts are looked up; only your decisions are asked. The agent reads the code, history, and documentation first. It asks only about choices you own (behavior, scope, cost, a step that is hard to undo) and takes the technical ones itself, telling you which it took and why.
• Ceremony matches the work. The agent sizes each request as Quick, Small, or Project and tells you why. A typo needs no issue; a feature gets one; a large effort gets a project.
• No agreement, no code. Beyond a Quick fix or a Linear issue that is ready to start, the agent builds only what you agreed to.
• Linear holds the work. Each feature or fix is a Linear issue and each large effort a Linear project, written so that any later session continues from it.
• One unit per session. Large work advances in units that one session can finish, check, and hand over as a change you can review in one sitting. Each conversation does one thing (a task, a fix, an investigation, an experiment, an interview, or a take-stock), then stops; the next starts from Linear. The agent plans only as far as what is known, and takes stock with you whenever a result changes the way ahead.
• Tests first. Each behavior starts with a failing test wherever a test boundary exists.
• Evidence over claims. Independent read-only reviewers check requirements, standards, and correctness, and the agent shows you the result running.
• Explained, not simplified. The agent keeps the real technical terms, defines each one the first time it appears, and presents every decision with its costs, whether it can be undone, and a recommendation.
• You hold the keys. Shipping (push and pull request), merging, and deploying each wait for your explicit yes.

General rules (communication, authorization, delegation, verification, Git) live once in a shared operating policy; each skill holds only what is specific to its task.

How it works

flowchart LR
    request([Your request]) --> work
    work -.->|bug, research, experiment| specialist{{"debug · research · prototype"}}
    specialist -.-> work
    work --> size{{Quick · Small · Project}}
    size -->|Quick| build[Build test-first]
    size -->|Small or Project| interview[interview, when decisions are open]
    interview --> agree([You agree])
    agree --> build
    build --> review[code-review]
    review --> show([Result shown working])
    show --> ship([Ship when you say yes])

You start everything with /work and your request, in your own words. The agent first finds the cause of a bug or gathers the evidence a decision needs, then sizes the work:

Small and Project work need Linear: when the agent cannot reach it, it stops and tells you how to reconnect. Quick work does not use Linear.

Get started

You need a coding agent that supports skills and subagents, and Node.js and npm for the installer.

1. Open a terminal in your project and install the stack:

   npx skills add Firzus/agent-skills --skill setup-harness work interview debug prototype research code-review
   

   The installer asks for your agent and destination. It installs in the project by default; add -g to install globally.

2. Run setup-harness once. It installs the shared operating policy in your personal instructions, after showing you the complete change. The stack relies on it.

3. Run /work with a small request, for example /work fix the typo in the confirmation email. Check the result it shows you, then tell it whether to ship.

If an invoked skill is not found, check the installation location and restart the session.

# Browse the collection without installing it
npx skills add Firzus/agent-skills --list

# Choose skills interactively
npx skills add Firzus/agent-skills

# Manage installed skills
npx skills list
npx skills update work
npx skills remove work

See the skills CLI documentation for supported agents, installation modes, and troubleshooting.

Choose by task

Some skills work on their own, without the rest of the stack.

Stack and engineering skills assume the shared operating policy, even when used alone.

Requirements

Installing instructions does not install every tool they describe or authorize every action they can perform. Check the selected skill's prerequisites first.

Host support for installing skills does not guarantee identical behavior or tool availability. Explicit-invocation workflows such as work, improve-architecture, and setup-harness run only when you select them.

Personal harness instructions

setup-harness asks which harnesses and languages to configure, previews the complete changes, and waits for approval. It adds personal instructions without replacing the built-in system prompt and creates no backups. Existing unrelated instructions are preserved.

Cursor's project AGENTS.md is not a global substitute. See the native destinations for loading limits, and review the shared operating policy before running this skill.

Tauri companion tooling

The tauri skill remains the agent-facing entry point. Its optional Windows diagnostic application, tauri-agent-kit, is maintained in this repository but is not an installable skill. Installing the skill does not install the MCP server or Rust plugin: the skill proposes the integration when a compatible project lacks it, and installs it only after approval. Check the kit's compatibility and publication status before integrating it into an application.

Reverse-engineer companion server

The reverse-engineer skill works with shell commands alone, but it is faster and more economical with its read-only MCP server, mcp/reverse-engineer. Installing the skill does not install the server: register its npm package, reverse-engineer (alpha), with your agent, as described in its README.

All skills

Stack

Engineering

Web and app development

Game development

Contribute

Found a problem? Open an issue with the skill name, agent and version, expected result, and actual result. Remove secrets and private project data from examples.

For repository changes, read AGENTS.md for contribution boundaries and validation. A skill lives at skills/<section>/<name>/SKILL.md; supporting references and helpers stay in its folder. Keep the README catalog and marketplace manifest aligned with skill folders.

Licensed under MIT.