/// system

Turn AI agents intodisciplined senior engineers.

Most skill libraries sell capability.We sell discipline you can verify.

install - three channels
Pick one — all three install the same framework.
git~ $git clone https://github.com/juandelossantos/another-agent-skills.git && cd another-agent-skills && bash install.sh
curl~ $curl -fsSL https://github.com/juandelossantos/another-agent-skills/releases/latest/download/bootstrap.sh | bash
npm~ $npx @juandelossantos/another-agent-skills installrecommended
Detected: OpenCode · Claude Code · Cursor · Codex · Gemini
Installed 58 skills · wired the harness · armed the gates.
DONE. Run init-agents in any project.
Channels: git, curl and npm — all live.
DEFINEPLANBUILDVERIFYREVIEWSHIP
npx @juandelossantos/another-agent-skills install

Step 1 — start here

Wire the gates with the /gate skill

One skill. It detects your stack, installs the local hooks, the TDD gate and the required CI check, then proves the first gate actually fires. Everything else builds on this.

> /gate

  Detecting  · VCS: git · stack: Node · hooksPath: unset
  Wiring     · L1 local hooks · L2 required gates check · L3 CODEOWNERS
  Proving    · git commit → ✗ BLOCKED: every code change needs a matching test

Enforcement works with any git-based agent — OpenCode, Claude Code, Cursor, Codex, Gemini CLI, and any agent that reads AGENTS.md.

See the /gate skill

Agents default to the shortest path.

TL;DR: capable models still skip tests, review, and context. The gap is process, not intelligence.

No tests before commit

Code that looks correct and breaks in production.

No review before push

Two agents overwrite each other without noticing.

Generic output only

The same patterns regardless of context or stack.

Failures are silent

Damage is discovered hours later, by a human.

When developers used AI, they took 19 percent longer. They estimated AI saved them 20 percent of the time.

Becker et al., METR, July 2025

The gap between capable and reliable is not intelligence. It is process.

01 / lifecycle

Six phases. A path that draws itself.

TL;DR: every task runs DEFINE, PLAN, BUILD, VERIFY, REVIEW, SHIP. No phase is optional and each one has an exit criterion.

  1. DEFINE/specSpec approved, scope locked
  2. PLAN/planTasks small, dependencies mapped
  3. BUILD/buildOne slice, tests written first
  4. VERIFY/verifyTests pass, behavior matches spec
  5. REVIEW/reviewNo P0 issues, security checked
  6. SHIP/shipClean commit, gates green

No phase is optional. Every step has a skill. Every skill has a gate.

02 / the harness

A task flows down the machine.

TL;DR: the Harness is six layers around the model. A bad change reaches the guardrails layer and is blocked there, then logged.

  1. Instructions

    Who the agent is and what it must never do.

  2. Tools

    Task-specific capabilities, loaded on demand.

  3. Sandboxes

    Where commands run, isolated from your system.

  4. Orchestration

    When tools fire and how agents coordinate.

  5. Guardrails

    Deterministic hooks at lifecycle points.

    BLOCKED
  6. Observability

    Evidence it works or is quietly drifting.

    logged

Blocked at Guardrails: a code change arrived without a matching test. Observability recorded it.

A rule that lives only in a file is a suggestion. A rule that lives in a layer is a gate.

03 / the loop

The agent that audits itself.

TL;DR: every session can audit, diagnose, fix, and record an ADR. Findings become fixes, and fixes become decisions on record.

  • Audit: scan core files for drift
  • Diagnose: classify the root cause
  • Fix: propose and apply with approval
  • ADR: record the decision
  • Repeat: each run raises the floor

Verification without evidence is inspection.

12issues found
12fixed
0regressions

04 / enforcement

Show the block. Do not promise it.

TL;DR: a code change with no matching test is blocked locally by L1, the local approval is bound to the exact staged tree and consumed once, and nothing merges without the remote gates check at L2.

L1

Local hooks

Fast, advisory feedback before a commit leaves your machine. The approval is bound to the exact staged tree and consumed once.

L2

Remote gates check

A required status check. It also verifies the PR head tree against the human-approved digest. The committer cannot skip it. GitHub only.

L3

CODEOWNERS review

A human owns the sensitive paths. Review is required. GitHub only.

Real output: a blocked commit
$ git commit -m "feat: add checkout"
[commit-msg v6] scanning staged files
[commit-msg v6] code changed: src/checkout.js
[commit-msg v6] matching test: none
✗ BLOCKED: every code change needs a matching test.

The same check runs remotely as the required gates status, so it cannot be bypassed by the committer.

Read the remote enforcement evidence

One install. Any agent. Any stack.

TL;DR: the installer detects your agent and your stack, then wires the matching skills and hooks.

  • OpenCode
  • Claude Code
  • Cursor
  • Codex
  • Gemini CLI
  • GitHub Copilot
  • Windsurf
  • Aider
  • Kiro
  • Zed
  • 15 agents detected

Stack-agnostic: Node, Rust, Python, Go, Ruby, Dart, or any stack. init-agents writes STACK_CONFIG.md.

See the agent adapter matrix

05 / skills

Skills, chipped by phase.

TL;DR: 58 curated skills mapped to the lifecycle. Use all of them or the ones your workflow needs.

DEFINE

Foundation

Contracts, context, and the interview that locks scope before code.

spec-driven-developmentinterview-meidea-refineengineering-fundamentalscontext-engineering

PLAN

Process

planning-and-task-breakdownarchitecture-analysisdoubt-driven-developmentmulti-agent-orchestration

BUILD

Build

incremental-implementationtest-driven-developmentsource-driven-developmentfrontend-webbackend-api-masteryapi-and-interface-design

VERIFY

Verify

debugging-and-error-recoverydebugging-three-strikesbrowser-testing-with-devtoolsproject-health-check

REVIEW

Review

code-review-and-qualitysecurity-and-hardeningperformance-optimizationaudit-skillcritique-skillcode-simplification

SHIP

Ship

git-workflow-and-versioningci-cd-and-automationshipping-and-launchfullstack-shippingdocumentation-and-adrsobservability-and-instrumentation

Design review

Design review suite

critique-skillaudit-skillclarify-skillhard-skillpolish-skilltypeset-skilladapt-skilloptimize-skilldelight-skillredesign-skill

Meta

Meta-skills

skill-creatorskill-improverself-improvementproject-metrics

58 skills · 153 guides · 6 harness components · an eval for each

Browse the full catalog

Enforcement that adapts to your project.

TL;DR: with no git you get rules only. Add git for L1 hooks. Add GitHub for L2 and L3. Re-run init-agents after each change.

No git

L1L2L3

Independent or private, no VCS. Rules and AGENTS.md install, but there are no hooks and no remote gate. Enforcement is convention only.

Upgrade:git initthen re-runinit-agents

Local git

L1L2L3

A private repo or a non-GitHub forge. L1 hooks are active. There is no L2 or L3, so the remote authority is missing.

Upgrade:git remote add origin <url>then re-runinit-agents

Git + GitHub

L1L2L3

Full L1 + L2 + L3. The remote gates check is required, CODEOWNERS owns sensitive paths, and the committer cannot skip either.

Apply:setup-branch-protection.sh --dry-run

Git later

L1L2L3

No git now, git and GitHub later. The key rule: re-run init-agents after git init and after adding the remote. It detects what is now available and installs the missing layers.

Rule:init-agentsafter each change

06 / faq

Questions, answered plainly.

What is Another Agent Skills?

A framework of 58 composable skills that turn AI coding agents into disciplined senior engineers. It adds mechanical enforcement, not just prompts. Skills follow a six-phase lifecycle: Define, Plan, Build, Verify, Review, Ship.

How does mechanical enforcement work?

Three layers. L1 is local git hooks for fast, advisory feedback, and its approval is bound to the exact staged tree and consumed once. L2 is a required remote gates check that verifies the PR head tree against the human-approved digest and cannot be skipped. L3 is CODEOWNERS review for sensitive paths. A code change with no matching test is blocked, locally and remotely.

Which agents does it support?

Designed for OpenCode. Portable to Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, Windsurf, Aider, and any agent that reads AGENTS.md. The installer detects the agent and wires the matching skills and hooks.

Is it free?

Yes. MIT License. Open source. No subscriptions and no paid tiers. The installer, the skills, and the enforcement are all free.

Can an agent still break the rules?

Yes. The hooks make it harder, not impossible. The L1 approval is bound to the exact staged tree and consumed once, so it cannot be replayed or swapped after the fact, but a local agent with a shell can still forge it. The remote gates check is the authority. These gates create friction, not guarantees. The human stays in the loop, and the human stays alert.

What is the Harness?

The Harness is everything around the model that turns raw intelligence into reliable output: instructions, tools, sandboxes, orchestration, guardrails, and observability. Agent equals Model plus Harness. Most agent failures are configuration failures.

How do I install it?

Three channels. Clone and run install.sh, or use the pinned curl bootstrap from the latest release, or install through npm. Then run init-agents in any project. All three are live today.

07 / start

Give your agent a gate it cannot forget.

One command. The installer detects your agent and your stack, then arms the enforcement.

npx @juandelossantos/another-agent-skills install
  • git clonelive
  • curl bootstraplive
  • npx @juandelossantos/another-agent-skillslive