Skip to content
Skills Library
Programming · Planning

greybeard

/greybeard

No more AI slop. An architect skill: before any code, the idea must pass three gates - is it needed, is it worth the time, will someone run it - and it warns and stops if one fails (AI slop, or more to build and run than it is worth). Then it designs the whole architecture first and fits every user story into it - SOLID, open/closed extension points, Unix philosophy, right-sized (neither over- nor under-engineered), with a committed decision record and enforceable architecture rules. Design only; it writes no implementation code. Use when asked to design, architect, plan or review the architec

Repository
greybeard ↗
Licence
MIT
Last repository change
28.10.2026

Assessment and security

90/ 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.
Content25 / 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
7
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 28.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

No more AI slop. An architect skill: before any code, the idea must pass three gates - is it needed, is it worth the time, will someone run it - and it warns and stops if one fails (AI slop, or more to build and run than it is worth). Then it designs the whole architecture first and fits every user story into it - SOLID, open/closed extension points, Unix philosophy, right-sized (neither over- nor under-engineered), with a committed decision record and enforceable architecture rules. Design only; it writes no implementation code. Use when asked to design, architect, plan or review the architec

Original author description

No more AI slop. An architect skill: before any code, the idea must pass three gates - is it needed, is it worth the time, will someone run it - and it warns and stops if one fails (AI slop, or more to build and run than it is worth). Then it designs the whole architecture first and fits every user story into it - SOLID, open/closed extension points, Unix philosophy, right-sized (neither over- nor under-engineered), with a committed decision record and enforceable architecture rules. Design only; it writes no implementation code. Use when asked to design, architect, plan or review the architec

How it works

  1. 0. Three gates (read references/viability.md)
  2. 1. Constraints
  3. 2. Size it (read references/sizing.md)
  4. 3. Architecture first, stories second
  5. 4. Right-size (read references/production.md)
  6. 5. Self-review (read references/checklist.md)
  7. 6. Deliverables
Original SKILL.md headings · 82 lines, 627 words
SKILL.md preview
---
name: greybeard
description: "No more AI slop. An architect skill: before any code, the idea must pass three gates - is it needed, is it worth the time, will someone run it - and it warns and stops if one fails (AI slop, or more to build and run than it is worth). Then it designs the whole architecture first and fits every user story into it - SOLID, open/closed extension points, Unix philosophy, right-sized (neither over- nor under-engineered), with a committed decision record and enforceable architecture rules. Design only; it writes no implementation code. Use when asked to design, architect, plan or review the architecture of a new system, service, platform or major feature, or to decide whether something is worth building. Triggers on \"design a system\", \"architecture for\", \"architect this\", \"system design\", \"should we build\", \"is this worth building\", \"tech design\", \"design doc\", \"ADR\", \"AI slop\"."
---

# Greybeard - the architect skill

**No more AI slop.** Code is nearly free now; judgement, production scars and operating cost
are not. Design as the architect who will still own this system in three years.

**Design only.** Write no implementation code. Work through the steps in order; each step names
the reference file to read when you reach it, not before.

## 0. Three gates (read `references/viability.md`)

Before any design, the idea must pass three gates. Answer each in writing:

1. **Is it needed?** Who is it for, and does an existing product, library or service already
   do 80% of it?
2. **Is it worth the time?** People-months for one person to first real use and to the parity
   users expect, compared with reusing the best alternative.
3. **Will someone run it?** The production bill (restarts, upgrades, security, on-call, for
   years) and the owner who pays it.

Then give a verdict:

- **GO** - it passes all three gates; build it.
- **GO, NARROWED** - build only the stated smaller thing that passes, usually a thin layer on a
  reused product.
- **STOP** - it fails a gate. Say which one and why, name the alternative, and **do not
  design**. Continue only if the user accepts the risk; record that as decision D1.

A gate that never says STOP is decoration. Infrastructure that every company needs and
mature products already provide is STOP or NARROWED unless the facts name a requirement no
existing option meets.

## 1. Constraints

List the constraints given and the missing ones that would change the design. Ask for them. If
you must assume, label it `ASSUMPTION` and say what changes if it is wrong.

## 2. Size it (read `references/sizing.md`)

Do the arithmetic before choosing technology: peak load, per-request budget, working set vs
memory, growth. Name the bottleneck. Every later choice traces back to a number.

## 3. Architecture first, stories second

1. Draw the whole system: components with one responsibility each, data ownership, one contract
   style, dependencies pointing at abstractions. Give each component its own budget (time,
   requests, tokens, money), not only a global cap.
2. Walk every user story through it. A story that does not fit changes the architecture
   deliberately and gets a decision; it does not get a patch.
3. **SOLID, Unix philosophy, open/closed.** Name the 2-4 axes that will really change (the
   runtime that executes the work is usually one) and put an extension point on each. No seams
   on axes nobody can justify.

## 4. Right-size (read `references/production.md`)

POCs become products. Bake in now what is cheap today and painful later: data and cache
versioning, complete cache keys, identity, restart survival, idempotent retries, failure
semantics, the hot-path data layout, observability. Defer heavy infrastructure (Kubernetes,
buses, microservice splits, multi-region) until a stated fact demands it, and write the trigger.

**Simple infrastructure, not a simple hot path.** "Don't over-engineer" is about moving parts to
operate. Never drop a pruning step, cache tier, input cap or safety mechanism on the bottleneck
for simplicity alone; rejecting one needs a number.

## 5. Self-review (read `references/checklist.md`)

Fix gaps; do not just note them.

## 6. Deliverables

1. `design.md` - verdict, constraints, sizing, architecture, story walk-through, rejected
   alternatives, risks. Mechanisms and numbers, not prose; do not paste this method into it. A
   longer document is not a better design.
2. `decisions.json` - committed decisions (`references/decision-record.md`). Pick one option and
   state when you would switch.
3. `ARCHITECTURE.md` - the rules coding agents load every session, each with **its why** and
   **how it is enforced** (`references/enforcement.md`). Agents forget prose after context
   compaction; they cannot ignore a failing check. Name 3-7 automated checks for the rules that
   matter most.

Later changes that do not fit `ARCHITECTURE.md` are design changes: come back to step 3.
Files in this package (7)
  • SKILL.md 5 KB
  • references/checklist.md 5 KB
  • references/decision-record.md 2 KB
  • references/enforcement.md 2 KB
  • references/production.md 2 KB
  • references/sizing.md 1 KB
  • references/viability.md 3 KB

Versions

The database has no other skills named greybeard.

Database snapshot: 13.11.2026 · package version 1ae69293900a (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

  • 100solid-principles-code-review-compliance
    Use this skill when review object-oriented architectures for compliance with SOLID software design principles.
  • 84unix-architect
    Write ADRs or review PRs/proposals as a UNIX philosophy architect. Use when making architectural decisions, evaluating technical proposals, or recording design rationale.
  • 95mkl-solid-code-development
    Develop or evolve code through requirements clarification, a requirements baseline, analysis, high-level architecture, detailed design, coding, change review, and architecture review. Use for business-correct SOLID code that remains understandable, extensible, maintainable, and…
  • 90code-architect
    Design a feature architecture by analyzing existing codebase patterns and conventions, then provide a comprehensive implementation blueprint with specific files to create or modify, component designs, data flows, and a build sequence. Use this skill when the user asks for an…
  • 90review-architecture
    Review code from a high-level system architecture perspective — SOLID principles, design patterns, module coupling, and API design. Use when auditing structural integrity, dependencies, or component boundaries. Invoked by /ac:review.
  • 90technical-architect
    Designs system architecture: components, data model, APIs, scaling and trade-offs, with diagrams. Use for designing a new system, scaling an existing one, choosing between architectures, or writing an architecture decision record.

Feedback and reports

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