cihatcoban/keystone
Master-level engineering skills for AI coding agents — architecture-first, stack-agnostic, from intent to operations. Works in Claude Code, Gemini CLI and Codex.
Secures the coding agent's own toolchain - MCP servers, plugins, skills, hooks, permission and approval modes, credentials the agent can reach. Use before adding or trusting agent tooling. Triggers - add an MCP server, is this plugin safe, audit agent config, yolo mode, pin MCP version, hook runs a script.
Coordinates several agents on one task - splitting work, parallel subagents, fresh-context verification, loop specs and stop conditions. Triggers - use subagents, run this in parallel, split this across agents, agent keeps retrying, design an agent loop, run this unattended, verify with a fresh agent.
Puts an LLM into a product safely - bounded role, schema-validated output, prompt-injection defense, retrieval, cost, evals, human decision points. Use when a model enters a product path. Triggers - add an LLM, AI feature, prompt injection, should the model decide, hallucination, RAG, LLM cost, structured output.
Designs interfaces other systems depend on - REST, GraphQL, gRPC, events, webhooks - with versioning, compatibility and error contracts. Use when creating or changing a public surface. Triggers - design REST endpoints, breaking change, API versioning, what should this return on error, event schema, contract test.
Makes and records a costly-to-reverse technical decision as an ADR - forces, options, trade-offs, reversibility. Triggers - should we use a queue or direct calls, X or Y, build or buy, write an ADR, which database, monolith or microservices, why is the system built this way.
Structures modules and dependency direction so changes stay local - ports and adapters, the dependency rule, coupling, cycles. Triggers - one change touches twenty files, circular dependency, where should this new code live, everything is coupled, hexagonal or clean architecture, layering.
Reviews a change before merge - correctness, failure behavior, design, security, performance, tests - and blocks quiet erosion of the quality bar, including in agent-written code. Triggers - review this pull request, code review, is this ready to merge, look over my changes before I push.
Handles shared mutable state correctly - races, locks, transaction isolation, lost updates, async correctness. Triggers - two requests update the same row and lose data, race condition, which isolation level, deadlock, optimistic locking, test fails intermittently under load, double submit.
Manages configuration and secrets - .env and .env.example, environment variables, API keys for Anthropic, OpenAI and Gemini, startup validation, keeping secrets out of the repo and out of agents. Triggers - .env file, env var, where do I put this API key, dotenv, secret leaked, config validation.
Turns a project's quality bar into a written contract with numbers and stops agents quietly lowering it. Triggers - what coverage target should we set, define our quality standards, agent keeps disabling checks or skipping tests to get green, what threshold to use.
Sets up what an agent knows about a repository - operating contract, conventions, session hygiene, compaction. Triggers - set up CLAUDE.md, AGENTS.md or GEMINI.md, agent keeps ignoring our conventions, output quality dropped in a long session, context window full, when to compact, repo rules.
Designs schemas, constraints, indexes and storage choices, and changes them safely with expand-contract migrations. Triggers - design the schema, add a column, write the migration, which database, document database or relational, index this query, slow query, backfill.
Finds the real cause of a defect systematically, including intermittent and production-only failures. Triggers - it worked yesterday and now it doesn't, can't reproduce, crashed with this stack trace, why is this failing, works on my machine, debug this, unexpected result.
Gates every new dependency, model, dataset or copied snippet on necessity, health, license and supply-chain risk. Triggers - should we add this library, is this license compatible, GPL, copied this snippet from Stack Overflow, upgrade a major version, model weights license.
Removes or replaces something people depend on without breaking them - usage measurement, sunset, consumer migration, dual-running, safe deletion. Triggers - can we delete this old endpoint, deprecate, sunset this feature, move users off the legacy system, dual write.
Makes code survive partial failure - timeouts, retries, idempotency, backpressure, circuit breakers, outbox, sagas. Triggers - calling an external API, how should retries work, timeout, duplicate messages from the queue, webhook, exactly once, cascading failure.
Writes documentation that stays true - README, runbooks, API docs, architecture overview - and prunes what rotted. Triggers - write the README, the setup docs are wrong, we need a runbook for this alert, document this service, onboarding guide.
Models a business domain so code uses the business's words and enforces its rules - bounded contexts, invariants, aggregates. Triggers - code and business use different words, entity or value object, where do these business rules belong, DDD, bounded context, aggregate.
Structures UI for correctness, accessibility and performance - state ownership, data fetching, components, accessible widgets, rendering budgets. Triggers - build the settings page, where should this component state live, page feels slow or jumps while loading, make this modal accessible, WCAG, form handling.
Keeps history reviewable and recoverable - atomic commits, branching, conflicts, PR hygiene, bisect, recovery. Triggers - write a commit message, split this messy working tree into clean commits, find the commit that broke this, merge conflict, rebase or merge, undo a commit.
Runs a production incident - mitigate first, coordinate, communicate - then a blameless postmortem with tracked actions. Triggers - production is down, users are reporting errors right now, outage, page fired, write the postmortem, rollback now, sev1.
Implements a planned task in thin vertical slices that each leave the system shippable, behind flags where needed. Triggers - implement the next task from the plan, start coding, how do I land this big change safely, should this go behind a feature flag, long-lived branch.
Instruments a system so production is explainable, and defines SLIs, SLOs and alerts worth waking for. Triggers - we could not tell what happened during the outage, what should we log, define an SLO, metrics, tracing, error budget, alert noise.
Diagnoses performance problems measurement-first - profiling, budgets, queueing, caching - and guards wins in CI. Triggers - this endpoint is slow, hitting the latency budget, memory keeps growing under load, optimize this, N+1 query, high CPU, load test.
Decomposes an approved spec into small, ordered, independently verifiable tasks. Triggers - break this spec into tasks, make a plan, how should we sequence this work, where do we start, this task feels too big to start.
Improves structure without changing behavior, including legacy code with no tests - characterization tests, seams, strangler fig. Triggers - clean this module up, this legacy code has no tests and I need to change it, reduce the complexity, refactor, simplify.
Ships safely - versioning, changelog, reproducible builds, staged rollout, rollback, release-time migrations. Triggers - ship this to production, deploy, how should we roll this out, we need a rollback plan, version bump, canary, broke production after deploy.
Extracts what someone actually needs before anything is built, one question at a time. Triggers - build me an admin dashboard (or any X), interview me about what I need, stress-test my thinking, vague request, are we sure about this, grill me.
Threat-models and hardens a change - untrusted input, authentication, authorization, supply chain, personal data. Triggers - is this endpoint secure, threat-model this feature, we are storing personal data here, injection, permissions, OWASP, vulnerability, login and session cookies, CSRF.
Writes or extends a Keystone skill, including product-specific domain packs. Triggers - add a new skill to this pack, this skill never triggers when I ask for it, write a domain pack for our product, skill too long, agent does not follow the skill, retire or merge skills, extend keystone.
Writes a specification with measurable acceptance criteria before code exists. Triggers - write a spec for this feature, we need a PRD before we start, what exactly are we building, define the scope, requirements doc.
Drives implementation with a failing test first, proves bug fixes with a reproduction test, and records RED/GREEN evidence per planned behavior. Triggers - write a failing test for this bug first, TDD, implement this plan test-first, red-green-refactor, prove this handles the edge cases.
Decides what to test, at which level, with what data, and fixes slow, flaky or false-confidence suites. Triggers - what should we test and at which level, tests pass but bugs still ship, the test suite takes twenty minutes, flaky test, contract or mutation testing.
Routes the current work to the right Keystone skills and chains them in order. Use at session start or when unsure which process applies. Triggers - which skill should I use, where do I start with this task, what is the process here, hangi skill, nereden başlayayım.