engineering-practices

Plugin engineering-practices from marketplace claude-skills in vnovakovits/claude-skills. Commands read from the repo's manifest — 2 days ago.

Skills (54)

• accidental-cio

  Apply Scott Millett's "The Accidental CIO — A Lean and Agile Playbook for IT Leaders" (Wiley, 2024) when designing or reviewing how a technology organisation decides, funds, governs and delivers work. Covers the five components of an adaptive IT operating model (organised, work, govern, talent, lead

• agent-retro

  Run a retrospective on a coding-agent session and improve the agent's environment, not the code. Combines Derby & Larsen's five-stage retrospective, Shigeo Shingo's poka-yoke (turn a mechanical mistake into a check that makes it impossible), and Matt Pocock's retro categories — navigation, automated

• api-design

  Design APIs that are clear, evolvable, and idiomatic to their protocol — covering REST (Fielding, Richardson Maturity Model, Massé), GraphQL, gRPC/protobuf, versioning strategies, pagination, error responses (RFC 7807 Problem Details), idempotency, authentication, documentation (OpenAPI), and the pr

• architecture-decision-records

  Apply Michael Nygard's Architecture Decision Records (ADRs) — lightweight, immutable Markdown documents that capture significant architectural decisions, their context, and their consequences. Covers Nygard's classic format, MADR, when a decision is "architecturally significant", supersession workfl

• art-of-unit-testing

  Apply Roy Osherove's "The Art of Unit Testing" (Manning — 2nd ed. 2013 in C#/.NET, 3rd ed. 2024 in JavaScript) — the practitioner's guide to writing trustworthy, maintainable, readable unit tests. Centers on Osherove's broad unit-of-work definition (entry point → observable exit point), his three-pa

• behavior-driven-development

  Apply Behavior-Driven Development (BDD) by Dan North, Gojko Adzic, Matt Wynne & Aslak Hellesøy, and Liz Keogh — covering the three practices (discovery, formulation, automation), three amigos workshops, Gherkin scenarios, Specification by Example, living documentation, Feature Injection, and pairing

• clean-code

  Apply Clean Code principles by Robert C. Martin (Uncle Bob) when writing new code, refactoring existing code, or reviewing changes in any language. Covers meaningful names, small functions, comments, formatting, objects vs data structures, error handling, boundaries, unit tests, classes, systems, em

• continuous-delivery

  Apply Jez Humble and David Farley's Continuous Delivery — the discipline of making software always release-ready through deployment pipelines, trunk-based development, automated everything, feature flags, branch-by-abstraction, and the four DORA metrics (deployment frequency, lead time, change failu

• cupid-properties

  Apply Dan North's CUPID properties (Composable, Unix philosophy, Predictable, Idiomatic, Domain-based) — a 2022 alternative framing to SOLID, oriented toward "joyful code" and properties to lean toward rather than principles to obey. Use when evaluating code quality, when SOLID feels like a rulebook

• debugging

  Find and fix bugs systematically with David Agans's "Debugging — The 9 Indispensable Rules" (2002) and Andreas Zeller's "Why Programs Fail" (2nd ed. 2009), led by a feedback-loop-first discipline — no theory until one fast, deterministic command goes red on this exact bug. Covers the defect → infect

• domain-driven-design

  Apply Domain-Driven Design (DDD) by Eric Evans and Vaughn Vernon when modeling complex business domains, designing aggregates, structuring bounded contexts, choosing between entities and value objects, or aligning code with domain language. Covers strategic design (ubiquitous language, bounded conte

• domain-modeling-made-functional

  Apply Scott Wlaschin's "Domain Modeling Made Functional" (Pragmatic Bookshelf, 2018), the functional rendering of domain-driven design. Covers making illegal states unrepresentable with algebraic data types, workflows as type signatures (Command → Result<Events, DomainError>), errors as values on a

• elements-of-style

  Write clearly and concisely by applying William Strunk Jr.'s "The Elements of Style" (1918; Strunk & White from 1959) to any English prose — PR descriptions, commit messages, READMEs, ADRs, design docs, tickets, release notes, emails, chat replies, UI copy, error messages, code comments, marketing p

• event-sourcing-cqrs

  Apply Event Sourcing and CQRS principles from Greg Young's CQRS Documents, Alexey Zimarev and Microsoft's architecture patterns when designing commands, write-side state, IHoldState interfaces, appliers, event payloads, streams, aggregate boundaries, read models or projections. Covers schema evoluti

• event-storming

  Apply Alberto Brandolini's Event Storming — a collaborative modeling technique using domain events on sticky notes to discover business processes, identify bounded contexts, and design software collaboratively. Covers Big Picture, Process Modeling, and Software Design levels, the color-coded sticky-

• example-mapping

  Apply Matt Wynne's Example Mapping — the four-colour discovery technique (yellow story, blue rules, green concrete examples, red questions) that breaks a story or spec into rules, hangs concrete examples under each rule, and surfaces open questions. Covers the 25-minute session, card conventions, sh

• flow-efficiency

  Apply Niklas Modig & Pär Åhlström's flow-efficiency framework from "This is Lean — Resolving the Efficiency Paradox" (2012). Covers the central paradox (resource efficiency vs flow efficiency), the efficiency matrix, Kingman's formula and why high utilization destroys flow, the three laws of process

• fractal-architecture

  Apply heuristics from Mark Seemann's "Code That Fits in Your Head" (2021) — fractal architecture, working-memory limits, cyclomatic complexity ceilings, vertical slices, encapsulation through invariants, functional core / imperative shell, checklists, and sustainable software engineering. Use when d

• grilling

  Run a relentless, structured interview that sharpens a plan, design, feature idea or piece of writing until every decision in it is made and written down. Questions come in short rounds, each with a recommended answer; the interviewer looks up facts in the code and docs itself and only asks the huma

• hexagonal-clean-architecture

  Apply Alistair Cockburn's Hexagonal Architecture (Ports and Adapters), Jeffrey Palermo's Onion Architecture, and Robert C. Martin's Clean Architecture — the family of architectural styles that put the domain at the center, push frameworks and I/O to the edges, and enforce inward-pointing dependencie

• kanban

  Apply Kanban as a method for managing knowledge work, based on Marcus Hammarberg & Joakim Sundén's "Kanban in Action" (Manning, 2014) with David J. Anderson's foundational Kanban Method ("Kanban", 2010) and Klaus Leopold's "Practical Kanban" (2017). Covers the four foundational principles, six core

• language-ext-csharp

  Apply the LanguageExt functional library for C# in its 4.x form (the Aff and Eff era, before version 5's K<F, A> redesign). Covers the core types (Option, Either, Validation, Fin, Aff, Eff, Seq), idioms for null elimination, errors as values, applicative vs monadic composition, async effect chaining

• lean-software-development

  Apply Mary & Tom Poppendieck's seven principles of Lean Software Development from "Lean Software Development — An Agile Toolkit" (2003) and "Implementing Lean Software Development" (2006). Covers the seven principles (eliminate waste, amplify learning, decide as late as possible, deliver as fast as

• make-work-visible

  Apply Dominica DeGrandis's "Making Work Visible — Exposing Time Theft to Optimize Work & Flow" (IT Revolution, 2017; 2nd ed. 2022). Covers the five thieves of time (too much WIP, unknown dependencies, unplanned work, conflicting priorities, neglected work), how to expose and counter each, the book's

• observability

  Apply modern observability practices from Charity Majors / Liz Fong-Jones / George Miranda's "Observability Engineering" (O'Reilly), Charity Majors' recent Observability 2.0 writing (2024-2025), Cindy Sridharan's essays, Google's SRE books, and the OpenTelemetry standard. Covers observability vs. mo

• philosophy-of-software-design

  Apply John Ousterhout's "A Philosophy of Software Design" (2018; 2nd ed. 2021) — design as the fight against complexity. Covers complexity's symptoms (change amplification, cognitive load, unknown unknowns) and causes (dependencies, obscurity), strategic vs tactical programming, deep vs shallow modu

• pr-writer

  Write, scope, size, and review pull requests that are fast and safe to review and merge. Grounded in Google's Engineering Practices, GitHub's PR guidance, the SmartBear/Cisco review study, Conventional Commits, LLVM's AI tool policy and agentic-PR research, plus delivery practice (expand/contract mi

• pragmatic-programmer

  Apply the broad heuristics from Andy Hunt & Dave Thomas's "The Pragmatic Programmer" (1999, 20th-anniversary ed. 2019) — DRY, orthogonality, tracer bullets, reversibility, programming by coincidence, design by contract, broken windows, knowledge portfolio, good-enough software, and the dozens of tip

• process-level-event-storming

  Apply Alberto Brandolini's Process Modeling level of Event Storming — modeling ONE business process in full sticky-note grammar (read model → actor → command → aggregate/external system → event → policy → …) on a timeline, with hot spots as first-class output. Covers the picture-that-explains-everyt

• product-development-flow

  Apply Don Reinertsen's "The Principles of Product Development Flow" (Celeritas, 2009), the quantitative case for flow in product work. Covers its 175 principles across eight areas (economics, queues, variability, batch size, WIP constraints, flow control under uncertainty, fast feedback, decentralis

• qa-handoff

  Update a ticket with what shipped and tell QA what to test, in lean, empathetic, user-journey language. Verifies what is actually merged, released and deployed, maps each change to the ticket it fixes, writes a short status (in production / open / left, by owner) and a numbered list of user journeys

• refactoring-to-patterns

  Apply Joshua Kerievsky's "Refactoring to Patterns" — the discipline of arriving at Gang of Four design patterns through refactoring driven by smells, not by upfront design. Includes the "refactor to / toward / away from a pattern" framing, the economic argument against pattern over-use, and the spec

• refactoring

  Apply Martin Fowler's refactoring discipline — changing the internal structure of code without changing its observable behavior — using the named refactorings catalog (Extract Function, Move Method, Replace Conditional with Polymorphism, etc.) and the code-smells catalog (Long Method, Feature Envy,

• responsibility-driven-design

  Apply Responsibility-Driven Design (RDD) by Rebecca Wirfs-Brock and Brian Wilkerson when designing classes, distributing behavior across objects, modeling a domain, or refactoring object-oriented code. Covers responsibilities, role stereotypes, CRC cards, collaborations, contracts, object neighborho

• running-lean

  Apply Ash Maurya's "Running Lean — Iterate from Plan A to a Plan That Works" (3rd edition, O'Reilly, 2022). Covers the Continuous Innovation Framework (Vision → Strategy → Continuous Innovation), the three stages of a product (Problem/Solution Fit → Product/Market Fit → Scale), the Lean Canvas, the

• service-atlas

  Survey a service's codebase and publish a Miro "atlas" of it — a Pete Hodgson tech debt wall (value × cost cards), SIG-style health scorecard, hotspot treemap (churn × size), change coupling, pay-down roadmap, code quality metrics (cyclomatic complexity risk profile, unit size, parameters, duplicati

• skill-router

  Pick the right engineering-practices skill, or sequence of skills, for the situation at hand. Maps common situations — a fuzzy idea, a feature to plan, code to write or test, a bug, legacy code, a design or architecture question, an event-sourced model, a review, a pull request, a slow team or proce

• solid-principles

  Apply the SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) by Robert C. Martin when designing classes, structuring inheritance hierarchies, defining interfaces, organizing dependencies, or reviewing object-oriented code. Includes

• splitting-user-stories

  Split user stories into small, valuable, independently-shippable slices using INVEST (Bill Wake), Richard Lawrence's 9-pattern flowchart, Mike Cohn's SPIDR, Gojko Adzic's hamburger method, Jeff Patton's story mapping, and Henrik Kniberg's MVP analogies. Use when a story is too big to ship in one spr

• systems-thinking-iceberg

  Apply the systems-thinking iceberg — events, patterns, systemic structures, mental models (and Daniel Kim's fifth level, vision) — to explain why a problem keeps happening and where to intervene. Draws on Peter Senge's The Fifth Discipline (levels of explanation, archetypes), Daniel Kim's Vision Dep

• teaching

  Teach a concept, language, library, codebase or technique over one or many sessions so that it sticks, using the evidence on how people learn. The learner does the thinking (generation, retrieval practice), reviews are spaced and interleaved, new material starts from what the learner already knows,

• test-data-patterns

  Apply the family of test arrangement patterns — Test Data Builder (Nat Pryce & Steve Freeman, GOOS 2009), Object Mother (Peter Schuh, popularised by Martin Fowler 2006), Arrange-Act-Assert (Bill Wake, 2001), Given-When-Then (Dan North, 2006), and chained Test Fixtures — that keep test setup readable

• test-driven-development

  Apply Test-Driven Development to drive outside-in design in small steps. Centers on the London/mockist school (Freeman & Pryce's GOOS, Sandro Mancuso's outside-in teaching) with Kent Beck's classical foundations and Mark Seemann's pragmatic heuristics. Covers sociable vs solitary unit tests and when

• ticket-writer

  Draft, write, structure, or improve engineering tickets — user stories, bug reports, spikes, feature requests — for any tracker (Jira, Linear, GitHub Issues, Shortcut, Asana). Enforces a problem-first structure (outcome → context → constraints → acceptance criteria → dependencies → open questions) d

• tidy-first

  Apply Kent Beck's "Tidy First?" approach — small structure changes (tidyings) separated from behavior changes, sequenced as "first / after / later / never", informed by software design as an economic activity (coupling, cohesion, optionality, discount rate). Use when about to make a behavior change

• to-tickets

  Break a plan, spec, grilling summary or conversation into a set of tracer-bullet tickets — thin, end-to-end slices that each work and can be demonstrated on their own — with explicit "blocked by" edges, so the work forms a dependency graph and anyone can pick up a ticket whose blockers are done. Cov

• toyota-kata

  Apply Mike Rother's Toyota Kata from "Toyota Kata — Managing People for Improvement, Adaptiveness and Superior Results" (McGraw-Hill, 2009) — structured, scientific improvement routines. Covers the Improvement Kata (4 steps — understand the direction, grasp the current condition, establish the next

• toyota-way

  Apply Jeffrey Liker's "The Toyota Way — 14 Management Principles from the World's Greatest Manufacturer" (2004; 2nd ed. 2021), the management system behind the Toyota Production System. Covers the 4P model (philosophy, process, people and partners, problem solving) and the 14 principles, the TPS hou

• two-axis-code-review

  Review a branch or pull request on two separate axes, reported side by side and never merged into one ranking. Standards — does the diff follow this repository's written rules (CLAUDE.md, AGENTS.md, CONTRIBUTING, coding standards) plus a baseline of Fowler's code smells? Spec — does it do what the t

• unit-testing-principles

  Apply Vladimir Khorikov's unit testing framework from "Unit Testing Principles, Practices, and Patterns" (Manning, 2020). Covers the four pillars (protection against regressions, resistance to refactoring, fast feedback, maintainability) and their unavoidable trade-offs, the three styles of unit tes

• user-story-mapping

  Apply Jeff Patton's User Story Mapping (O'Reilly, 2014) — arranging user stories into a two-dimensional map that preserves the user's narrative journey, which a flat backlog destroys. Covers the map's anatomy (backbone and ribs; activities, tasks, details), the two axes (narrative flow left-to-right

• value-stream-mapping

  Map how a request flows from ask to value — Mike Rother & John Shook's "Learning to See" (1999) and Karen Martin & Mike Osterling's "Value Stream Mapping" (2013), adapted to software and knowledge work. Covers scoping one value stream, the map grammar (process boxes with lead time, process time and

• working-effectively-with-legacy-code

  Apply Michael Feathers's techniques for changing code that lacks tests — characterization tests, seams (object/link/preprocessor), dependency-breaking refactorings (Sprout Method, Extract Interface, Subclass and Override, Wrap Method, Break Out Method Object), effect sketches, and the Legacy Code Ch

• xunit-test-patterns

  Apply Gerard Meszaros's "xUnit Test Patterns — Refactoring Test Code" (2007) — the canonical catalogue of test-automation patterns, the test-double taxonomy (Dummy, Stub, Spy, Mock, Fake), test smells, fixture strategies, and result-verification patterns. Use when writing or refactoring test code; d

Similar plugins