Local hooks
Fast, advisory feedback before a commit leaves your machine. The approval is bound to the exact staged tree and consumed once.
/// system
Most skill libraries sell capability.We sell discipline you can verify.
npx @juandelossantos/another-agent-skills installStep 1 — start here
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 testEnforcement works with any git-based agent — OpenCode, Claude Code, Cursor, Codex, Gemini CLI, and any agent that reads AGENTS.md.
See the /gate skillTL;DR: capable models still skip tests, review, and context. The gap is process, not intelligence.
Code that looks correct and breaks in production.
Two agents overwrite each other without noticing.
The same patterns regardless of context or stack.
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
TL;DR: every task runs DEFINE, PLAN, BUILD, VERIFY, REVIEW, SHIP. No phase is optional and each one has an exit criterion.
/specSpec approved, scope locked/planTasks small, dependencies mapped/buildOne slice, tests written first/verifyTests pass, behavior matches spec/reviewNo P0 issues, security checked/shipClean commit, gates greenNo phase is optional. Every step has a skill. Every skill has a gate.
02 / the harness
TL;DR: the Harness is six layers around the model. A bad change reaches the guardrails layer and is blocked there, then logged.
Who the agent is and what it must never do.
Task-specific capabilities, loaded on demand.
Where commands run, isolated from your system.
When tools fire and how agents coordinate.
Deterministic hooks at lifecycle points.
Evidence it works or is quietly drifting.
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
TL;DR: every session can audit, diagnose, fix, and record an ADR. Findings become fixes, and fixes become decisions on record.
Verification without evidence is inspection.
04 / enforcement
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.
Fast, advisory feedback before a commit leaves your machine. The approval is bound to the exact staged tree and consumed once.
A required status check. It also verifies the PR head tree against the human-approved digest. The committer cannot skip it. GitHub only.
A human owns the sensitive paths. Review is required. GitHub only.
$ 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.
TL;DR: the installer detects your agent and your stack, then wires the matching skills and hooks.
Stack-agnostic: Node, Rust, Python, Go, Ruby, Dart, or any stack. init-agents writes STACK_CONFIG.md.
See the agent adapter matrix05 / skills
TL;DR: 58 curated skills mapped to the lifecycle. Use all of them or the ones your workflow needs.
Contracts, context, and the interview that locks scope before code.
spec-driven-developmentinterview-meidea-refineengineering-fundamentalscontext-engineering
planning-and-task-breakdownarchitecture-analysisdoubt-driven-developmentmulti-agent-orchestration
incremental-implementationtest-driven-developmentsource-driven-developmentfrontend-webbackend-api-masteryapi-and-interface-design
debugging-and-error-recoverydebugging-three-strikesbrowser-testing-with-devtoolsproject-health-check
code-review-and-qualitysecurity-and-hardeningperformance-optimizationaudit-skillcritique-skillcode-simplification
git-workflow-and-versioningci-cd-and-automationshipping-and-launchfullstack-shippingdocumentation-and-adrsobservability-and-instrumentation
critique-skillaudit-skillclarify-skillhard-skillpolish-skilltypeset-skilladapt-skilloptimize-skilldelight-skillredesign-skill
skill-creatorskill-improverself-improvementproject-metrics
58 skills · 153 guides · 6 harness components · an eval for each
Browse the full catalogTL;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.
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
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
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
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
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.
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.
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.
Yes. MIT License. Open source. No subscriptions and no paid tiers. The installer, the skills, and the enforcement are all free.
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.
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.
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
One command. The installer detects your agent and your stack, then arms the enforcement.
npx @juandelossantos/another-agent-skills install