agent-skills
Health Warn
- License — License: MIT
- Description — Repository has a description
- Active repo — Last push 0 days ago
- Low visibility — Only 5 GitHub stars
Code Warn
- process.env — Environment variable access in mcp/reverse-engineer/bench/regrade.ts
- process.env — Environment variable access in mcp/reverse-engineer/bench/run.ts
- process.env — Environment variable access in mcp/reverse-engineer/bench/setup.ts
Permissions Pass
- Permissions — No dangerous permissions requested
No AI report is available for this listing yet.
Agent Skills for AI coding assistants
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 inskills/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) before the build starts, and takes
every other choice itself, telling you which it took and why. - Ceremony matches the work. The agent sizes each request as Direct, Issue, or
Project, after what it needs in Linear, 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 Direct 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{{Direct · Issue · Project}}
size -->|Direct| build[Build test-first]
size -->|Issue or Project| interview[interview, when decisions are open]
interview --> agree([You agree])
agree -->|new conversation after an interview| 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:
| Size | When | What you do |
|---|---|---|
| Direct | The request says everything that matters and is easy to undo | Check the result, then say whether to ship |
| Issue | One unit: fits one session and one reviewable change | Agree on the Linear issue (when decisions are open, you answer them in a first conversation that ends there), check the result, say whether to ship |
| Project | Several units, or questions that need research, an experiment, or a later decision first | Agree on a Linear project and its first issues; then start a new conversation for each unit with /work on the project or one of its issues: the agent runs that unit, asks for your decisions in Interview units and for your review, names the next one, and takes stock with you when results change the plan |
Issue-size and Project-size work need Linear: when the agent cannot reach it, it stops and
tells you how to reconnect. Direct 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.
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-reviewThe installer asks for your agent and destination. It installs in the project
by default; add-gto install globally.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.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.
| I want to… | Start with | Needs the stack |
|---|---|---|
| Take a request from idea to a shipped change | work | Yes |
| Settle open decisions on a plan or feature | interview | No |
| Review an existing change without modifying it | code-review | No |
| Diagnose a bug or verify an authorized fix | debug | No |
| Compare interface ideas or test feasibility | prototype | No |
| Investigate a question across multiple sources | research | No |
| Find refactors worth doing | improve-architecture | No |
| Audit security boundaries in a codebase | security-review | No |
| Explain how shipped software works from its files | reverse-engineer | No |
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.
| Workflow | Additional requirements |
|---|---|
| Stack and engineering skills | The shared operating policy installed by setup-harness; these skills rely on it and repeat only its safety boundaries |
| The stack | Git in the project; a Linear workspace the agent can read and write (for example through the Linear MCP server) for Issue-size and Project-size work; GitHub CLI or another way to open pull requests to ship |
| Independent reviews and delegated research | An agent with subagent support |
| Figma workflows | The Figma integration, account access, and approval for external writes |
| Cloudflare operations | The cf CLI from the npm package cf (open beta) and a Cloudflare account; the skill proposes the global install and waits for approval |
| Video reports | FFmpeg and access to the application being recorded |
| Agent play in Unity | The Unity CLI with com.unity.pipeline in the project, the Input System active, Python 3, and a host that can run the skill's play model as a subagent; FFmpeg to film a session |
| Runbooks | Bash to run them (Git Bash on Windows); an authenticated GitHub CLI to set secrets and variables, otherwise the runbook lists them to set by hand |
| YouTube transcription | Available captions, or the audio/transcription tools required by the selected route |
| Image generation | An authenticated Codex CLI setup with the image-generation capability described by the skill |
| Wordmark lettering | The image-generation setup above, and the potrace npm package as a project dev dependency, added after approval |
| Reverse engineering | The reverse-engineer MCP server for the fast route (Node.js 24.11+); the skill installs Ghidra, jadx or ilspycmd per user when a task needs them |
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.
| Harness | Personal instruction destination |
|---|---|
| Codex (app and CLI) | One shared AGENTS.md per CODEX_HOME (default ~/.codex) |
| Cursor | User Rules in Customize > Rules; manual handoff if UI editing is unavailable |
| Claude Code | ~/.claude/CLAUDE.md |
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
| Skill | Purpose |
|---|---|
| code-review | Independent read-only review of a change on requirements, standards, and correctness. |
| debug | Evidence-led diagnosis and verification of authorized bug fixes. |
| interview | Settle the user's decisions in short question rounds, each explained and with a recommendation. |
| prototype | Answer a design or feasibility question through an experiment. |
| research | Multi-source investigation with a reusable evidence dossier. |
| work | Entry point: size a request, settle decisions, build test-first, review, show, and ship on approval. |
Engineering
| Skill | Purpose |
|---|---|
| authoring | Write and review skills, their invocation conditions, references, and templates. |
| gamification | Engagement mechanics, motivation, and ethical design checks. |
| imagegen | Generate or edit raster images through Codex. |
| improve-architecture | Find architectural friction and propose evidenced refactors that preserve behavior. |
| instructions | Write and review project instructions and other agent-facing documentation outside skills. |
| monorepo | Workspace structure, package boundaries, task graphs, caching, affected CI, and release verification. |
| reverse-engineer | Explain shipped software (Electron apps, native binaries and Node addons, Go/Rust, .NET, APK) from its files, with cited evidence and an optional read-only MCP server. |
| runbook | Write an interactive bash runbook that guides a person through manual setup, credentials, or a cutover. |
| setup-harness | Install the shared operating policy as reviewed personal instructions for selected harnesses. |
| security-review | Investigate codebase security boundaries and report evidence-backed findings. |
| skills | Discover, install, maintain, and author agent skills. |
| unslop | Propose evidenced dead-code and slop removals in the conversation, then apply the accepted ones. |
| video-report | Record video evidence of real application behavior. |
| youtube-transcript | Turn video speech and visual evidence into a learning report. |
Web and app development
| Skill | Purpose |
|---|---|
| adsense | Publisher monetization, ad placement, policy, and performance. |
| astryx | Build interfaces with the Astryx design system. |
| cloudflare-cli | Operate Cloudflare resources and Workers projects through the cf CLI. |
| dokploy-best-practices | Deploy and operate applications with Dokploy. |
| extract-theme | Extract a website's design tokens for Tailwind and shadcn/ui. |
| lettering | Turn generated hand-drawn lettering into an animatable SVG wordmark. |
| nextjs | Build and migrate Next.js applications. |
| payload-cms | Model content, access rules, and hooks with Payload CMS. |
| shaders | Add GPU-driven visual effects to React interfaces. |
| swr | Manage React data fetching, caching, and mutations. |
| tanstack-query | Manage asynchronous server state with TanStack Query. |
| tanstack-router | Build type-safe routes with TanStack Router. |
| tanstack-start | Build full-stack applications with TanStack Start. |
| tanstack-store | Manage reactive client state with TanStack Store. |
| tauri | Build and validate Tauri desktop and mobile applications. |
| vite-plus | Configure Vite+ tooling, checks, and workspace tasks. |
| web-assets-optimization | Optimize images, video, fonts, SVG, and asset delivery. |
| web-extension | Build and package browser extensions. |
| zod | Validate data and evolve schemas with Zod. |
Game development
| Skill | Purpose |
|---|---|
| figma-to-unity | Implement Figma designs in Unity UI Toolkit. |
| unity-cli | Drive the Unity Editor from an agent and iterate while you test in it. |
| unity-core | Choose the appropriate tools for Unity development tasks; the other Unity skills build on it. |
| unity-editor-tools | Build custom Unity Editor tools and inspectors. |
| unity-multiplayer | Add networking, sessions, and dedicated servers to a Unity game. |
| unity-play | Let an agent play your Unity game in the Editor, turn by turn. |
| unity-rendering | Configure URP, lighting, and GPU-driven rendering in Unity. |
| unity-ui | Build runtime UI with Unity UI Toolkit. |
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, or one
level deeper for the Unity skills (skills/game/unity/<name>/); supporting
references and helpers stay in its folder. Keep the README catalog and
marketplace manifest aligned with skill folders.
Licensed under MIT.
Reviews (0)
Sign in to leave a review.
Leave a reviewNo results found