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
- Author
- alexcpn ↗
- Repository
- greybeard ↗
- Licence
- MIT
- Last repository change
- 28.10.2026
Assessment and security
- Files in this package
- 7
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 28.10.2026, without references to retired models or APIs.
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
- 0. Three gates (read references/viability.md)
- 1. Constraints
- 2. Size it (read references/sizing.md)
- 3. Architecture first, stories second
- 4. Right-size (read references/production.md)
- 5. Self-review (read references/checklist.md)
- 6. Deliverables
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.