Skip to content

cihatcoban/keystone

v3.0.5Apache-2.0

Master-level engineering skills for AI coding agents — architecture-first, stack-agnostic, from intent to operations. Works in Claude Code, Gemini CLI and Codex.

agent-and-toolchain-security

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.

agent-orchestration

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.

ai-integration-guardrails

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.

api-and-contract-design

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.

architecture-decisions

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.

boundaries-and-dependencies

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.

code-review-and-quality

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.

concurrency-and-consistency

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.

configuration-and-secrets

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.

constraint-driven-development

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.

context-engineering

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.

data-modeling-and-storage

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.

debugging-and-root-cause

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.

dependency-and-license-policy

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.

deprecation-and-migration

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.

distributed-systems-and-resilience

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.

documentation-and-knowledge

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.

domain-modeling

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.

frontend-architecture

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.

git-workflow

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.

incident-response

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.

incremental-delivery

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.

observability-and-slos

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.

performance-engineering

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.

planning-and-task-breakdown

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.

refactoring-and-simplification

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.

release-engineering

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.

requirements-interrogation

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.

security-and-threat-modeling

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.

skill-authoring

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.

spec-driven-development

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.

test-driven-development

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.

testing-strategy

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.

using-skills

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.