Skip to content
Skills Library
DevOps & cloud · Review & audit

simplicity

/simplicity

Apply Google SRE simplicity principles to design and operations: reduce essential vs accidental complexity, kill unused features, and prefer boring reliable designs. Use when reviewing architecture, killing complexity, or NALSD tradeoffs.

Licence
MIT
Last repository change
30.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
2
Deprecation

No signals detected. Repository changed on 30.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Apply Google SRE simplicity principles to design and operations: reduce essential vs accidental complexity, kill unused features, and prefer boring reliable designs. Use when reviewing architecture, killing complexity, or NALSD tradeoffs.

Original author description

Apply Google SRE simplicity principles to design and operations: reduce essential vs accidental complexity, kill unused features, and prefer boring reliable designs. Use when reviewing architecture, killing complexity, or NALSD tradeoffs.

How it works

  1. When to use
  2. Principles
  3. Workflow
  4. Decision guide
  5. Output template
  6. Anti-patterns
  7. Related skills
  8. Canonical references
  9. Agent notes
Original SKILL.md headings · 62 lines, 218 words
SKILL.md preview
---
name: simplicity
description: >-
  Apply Google SRE simplicity principles to design and operations: reduce essential vs accidental complexity, kill unused features, and prefer boring reliable designs. Use when reviewing architecture, killing complexity, or NALSD tradeoffs.
---

# Simplicity

**Domain:** `foundations`  
**Sources:** SRE Book 1e Ch9, Workbook Ch7

## When to use

- Architecture review smells over-engineered
- Reliability harmed by complexity
- Prioritizing cleanup vs features

## Principles

- Complexity is a reliable predictor of failure and toil.
- Remove accidental complexity aggressively; essential complexity still deserves clarity.
- Fewer moving parts beat clever parts.
- Simplicity is a feature — budget time for it.

## Workflow

1. List components on the CUJ critical path.
2. Mark each: essential / accidental / unknown.
3. Find unused flags, dual paths, orphan jobs, dead dashboards.
4. Propose deletions with rollback plan.
5. Measure: fewer deps, lower MTTR, fewer pages.

## Decision guide

- If two systems overlap → merge or delete one with explicit owner.
- If abstraction hides failure → simplify until failure modes are visible.

## Output template

```markdown
# Simplicity review
- Critical path components:
- Accidental complexity finds:
- Proposed removals:
- Risk + rollback:
```

## Anti-patterns

- Complexity for resume-driven development.
- Premature platforms.

## Related skills

`nalsd-system-design`, `designing-for-resilience`, `configuration-design`

## Canonical references

- [Simplicity](https://sre.google/sre-book/simplicity/)
- [Workbook Simplicity](https://sre.google/workbook/simplicity/)

## Agent notes

- Prefer live data (metrics, tickets, pages) over generic advice.
- Cite which Google SRE source informed a recommendation when useful.
- Keep outputs tactical: decisions, owners, next actions.
Files in this package (2)
  • SKILL.md 2 KB
  • reference.md 1 KB

Versions

The database has no other skills named simplicity.

Database snapshot: 13.11.2026 · package version 0d78d5006e82 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90simplicity-and-isolation
    Apply economy of mechanism and least common mechanism to reduce attack surface through simplicity and component isolation. Use when reviewing system architecture for unnecessary complexity, shared resources, or single points of failure.
  • 90simplicity-audit
    Essential vs accidental. Use when an adversarial review of a diff must name leftover machinery; when asked to simplify an area; or when code-review or grilling needs a thinnest-machine judgment.
  • 100simplify
    Review code for readability, reuse, and simplicity. Triggered by "/simplify" when user wants to refactor complex code, remove duplication, or improve clarity.
  • 100ai-engineering-reviewer
    Review source code, architecture, technical designs, and implementation plans for correctness, security, simplicity, maintainability, and testing. Use for code reviews and engineering critiques.
  • 90review-the-design
    Use when reviewing a proposed architecture, a tech plan, or a PR for soundness — drive it to correctness/simplicity/fit, enable rather than gatekeep, flag the open gate without declaring done over it.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.