By bricerising
Opinionated agent skills for cohesive enterprise software: workflow, architecture, patterns, testing, security, observability, and more.
Design or refactor multi-service system architecture (domain boundaries, service decomposition, event-driven vs request/response, CQRS, sagas, API gateways, data ownership). Use when work spans multiple processes/services, needs eventual consistency, or requires clearer integration seams. NOT for in-process code structure like GoF patterns (use design); NOT for applying timeouts/retries/breakers to a single call (use resilience).
Run architecture observability analysis on a git repository to measure coupling, boundary health, risk hotspots, and temporal drift. Use when you need empirical data about code structure before making architecture or refactoring decisions, or to validate that changes improved boundary discipline. NOT for choosing architecture patterns (use architecture); NOT for choosing code patterns (use design); NOT for adversarial code review (use review); NOT for trajectory prediction or trend forecasting from cluster activity (use forecast).
Triage and diagnose production or local issues by following logs → traces → metrics (HTTP/gRPC/async). Use when investigating errors, latency spikes, 5xx responses, SLO violations, or regressions in an instrumented app. NOT for adding new instrumentation (use observability); NOT for applying resilience patterns (use resilience).
Pick the right in-process code pattern for a refactoring or extensibility need (GoF creational/structural/behavioral), and access implementation guides for specific patterns. Use as a decision workflow when unsure which pattern family fits, or go directly to pattern references when you already know. NOT for multi-service/distributed architecture (use architecture).
Run a final "definition of done" check before shipping: verify correctness, tighten contracts/docs, and produce a change summary. Use at the end of non-trivial work to confirm nothing was missed before merge/release. NOT for writing tests (use testing); NOT for adversarial code review (use review); NOT for initial planning (use plan).
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
An opinionated set of agent skills that drive cohesive, high-quality enterprise software: readable, maintainable, testable, and safe to change.
Each skill is a small, self-contained playbook (workflow + checklists + examples) stored in a SKILL.md file. Most skills are language-agnostic; TypeScript is currently the only language-specific style guide.
AI coding agents produce inconsistent output without shared guardrails. Copy-paste prompt snippets drift across teams, and ad-hoc instructions don't compose. This playbook gives agents a structured library of composable skills so that code quality stays high regardless of who (or what) writes the code.
specs/templates/app-repo/AGENTS.md).PROMPTS.md.You do not need to read this repo cover-to-cover. Start with the three steps above, then open the specific skills/*/SKILL.md playbook(s) you need as you go.
Minimal "try it now" prompt (run this inside your app repo, not this playbook repo):
Use workflow (read skills/workflow/SKILL.md).
Please review this codebase for maintainability and resilience gaps.
Skills follow a default workflow: Define > Standardize > Harden > Verify.
| Skill | Purpose |
|---|---|
workflow | Auto-route work across skills; choose appropriate skills even if the user doesn't name them |
plan | Turn a request into an executable plan (tasks + acceptance + verification) |
spec | Write specs, contracts, plans, and task lists so agents converge on cohesive solutions |
architecture | Choose the smallest system pattern(s) for cross-service pressures |
design | Choose the smallest code pattern(s) for in-process design pressures |
archobs | Measure coupling, boundary health, and risk hotspots before architecture/refactoring decisions |
intel | Gather and shape intelligence signals from collected feeds into audience-aware output |
forecast | Predict likely next developments from internal patterns (git, archobs) and external signals (intel) |
| Skill | Purpose |
|---|---|
typescript | Runtime safety, explicit boundaries, typed errors, and maintainable module structure |
platform | Design shared platform packages (packages/shared) without becoming a "utils junk drawer" |
| Skill | Purpose |
|---|---|
resilience | Timeouts, retries/backoff, idempotency, circuit breakers, bulkheads |
security | Authn/authz, input validation, injection safety, secrets, SSRF guardrails |
observability | Logs/metrics/traces correlation, RED metrics, dashboards/alerts |
debug | Debug workflows (log > trace > metrics) for incidents, regressions, and SLO violations |
| Skill | Purpose |
|---|---|
testing | Consumer-focused tests that raise coverage without asserting implementation details |
review | Adversarial code review debate (critique > defense > rebuttal > verdict) |
finish | Definition-of-done pass (verification + boundary spot-check + crisp summary) |
Cross-cutting reference material shared across skills lives in skills/references/.
Each skill lives under skills/<name>/SKILL.md. The primary mode is conversational: ask for what you want and let the agent auto-select the right skills. If you want deterministic control, name specific skills explicitly.
For more prompt recipes (including a conversational bootstrap), see PROMPTS.md.
Detailed per-platform instructions are in INSTALL.md.
npx claudepluginhub bricerising/enterprise-software-playbook --plugin enterprise-software-playbookVerification-first engineering toolkit for Claude Code. 15 skills across a 5-phase spine (Investigate → Design → Implement → Verify → Ship), 8 specialist agents, an interactive setup wizard. Every skill has rationalizations + evidence requirements. Built for senior ICs and tech leads.
19 software engineering skills from Code Complete, APOSD, GoF, and Clean Architecture. Skills are internal (slash-invocable; injected via Read() — not auto-triggered). Research → plan → build workflow with Gate-field adaptive gates (Full | Standard | Minimal) and per-phase orchestrated commits.
Use this agent when you need to design scalable architecture and folder structures for new features or projects. Examples include: when starting a new feature module, refactoring existing code organization, planning microservice boundaries, designing component hierarchies, or establishing project structure conventions. For example: user: 'I need to add a user authentication system to my app' -> assistant: 'I'll use the code-architect agent to design the architecture and folder structure for your authentication system' -> <uses agent>. Another example: user: 'How should I organize my e-commerce product catalog feature?' -> assistant: 'Let me use the code-architect agent to design a scalable structure for your product catalog' -> <uses agent>.
26 domain skills + 5 verification tools for security-first full-stack engineering. Covers security, architecture, DevOps, AI, mobile, office docs, frontend design, and multi-agent coordination.
Architecture analysis, brainstorming, ADR generation, LLM-as-judge comparison, and spec gap resolution.
Composable AI skills framework covering the full software delivery lifecycle — design, architecture, implementation, testing, and review.