agent-skills

agent
Security Audit
Warn
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.

SUMMARY

Agent Skills for AI coding assistants

README.md

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.

skills.sh
License

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) 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.

  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, update, or remove installed skills
# 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)

No results found