choose-boring-technology
Skill6 starsChanged 34 days agoMITView on GitHub
Apply the "Choose Boring Technology" principle when evaluating tech stack decisions, adding new tools or frameworks, proposing a rewrite, or debating between a familiar vs. cutting-edge approach. Use this skill whenever someone is considering adopting a new library, language, database, or service—even if they frame it as "should we use X?", "what tech should we pick?", or "is it worth trying Y?". This skill helps teams resist shiny-object syndrome and make grounded technology choices.
In this repository79 other files it gives its agents.
- adr-phase-coverageSkill
- aposd-red-flag-reviewSkill
- apple-on-device-aiSkill
- artifact-gatesSkill
- asc-app-create-uiSkill
- asc-build-lifecycleSkill
- asc-cli-usageSkill
- asc-crash-triageSkill
- asc-id-resolverSkill
- asc-localize-metadataSkill
- asc-metadata-syncSkill
- asc-notarizationSkill
- asc-ppp-pricingSkill
- asc-release-flowSkill
- asc-revenuecat-catalog-syncSkill
- asc-shots-pipelineSkill
- asc-signing-setupSkill
- asc-submission-healthSkill
- asc-subscription-localizationSkill
- asc-testflight-orchestrationSkill
- asc-wall-submitSkill
- asc-workflowSkill
- asc-xcode-buildSkill
- ci-preflightSkill
- conways-lawSkill
- cost-routingSkill
- cost-tier-routingSkill
- cunninghams-lawSkill
- ddd-strategic-auditSkill
- ddd-tactical-reviewSkill
- debug-test-captureSkill
- developing-ios-appsSkill
- doerrs-lawSkill
- fitts-lawSkill
- fix-regression-guardSkill
- galls-lawSkill
- goodharts-lawSkill
- greenspuns-tenth-ruleSkill
- gsd-core-hooksSkill
- hofstadters-lawSkill
- hyrums-lawSkill
- ios-accessibilitySkill
- ios-simulator-boot-healthSkill
- kerckhoffs-principleSkill
- kernighans-lawSkill
- knuths-optimization-principleSkill
- lady-lovelaces-objectionSkill
- leaky-abstractionsSkill
- linuss-lawSkill
- mobile-ios-designSkill
- money-boundary-judgmentSkill
- moores-lawSkill
- no-deferSkill
- norvigs-lawSkill
- parkinsons-lawSkill
- peter-principleSkill
- postels-lawSkill
- post-fix-traceSkill
- qa-test-architectSkill
- rubber-duckSkill
- The first 60 shown.
The file
We split this skill into the rules it gives an agent
4 rules. About 0 are common, 4 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈4
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 26
Ask these questions about the proposed tech:
- Distinctive: line 34
If you do adopt something new, keep the old thing running where it already works.
- Distinctive: line 51
When helping someone with a tech decision, work through:
- Distinctive: line 55
If we adopt this, who will be on call when it breaks at midnight?
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Choose Boring Technology
"Consider how you would solve your immediate problem without adding anything new." — Dan McKinley, 2015
The core idea
McKinley's essay argues that every new technology you adopt is a "complexity token" you spend — and you only have a limited budget. Novel technologies bring unknown failure modes, thin internal expertise, and higher cognitive load. Boring technologies (well-understood, widely deployed, battle-tested) have predictable failure modes, rich documentation, broad community knowledge, and don't surprise you at 2am.
The law doesn't say "never adopt new tech." It says: be deliberate about when you do, and have a high bar.
How to apply it
Step 1 — Solve the problem with what you have first. Before evaluating any new option, ask: can you solve this with something already in your stack? A Postgres table instead of a new cache? A cron job instead of a message queue? The answer is often yes, and the boring solution is usually good enough longer than you expect.
Step 2 — Budget your complexity tokens. Assess how many unfamiliar technologies are already in flight on the team. If you're already running Kubernetes, a new microservices framework, and a new language, adding another unknown is risky. Teams have limited capacity to learn and operate things reliably.
Step 3 — Score the tradeoff honestly. Ask these questions about the proposed tech:
- Does anyone on the team have real production experience with it?
- What does failure look like, and do we know how to recover?
- Is there a boring alternative that covers 80% of the use case?
- What's the operational cost (monitoring, on-call, upgrades)?
- Are we adopting this because it actually solves our problem, or because it's interesting?
Step 4 — Prefer addition over replacement. If you do adopt something new, keep the old thing running where it already works. Don't rip and replace — introduce incrementally and let the new thing earn its footprint.
When boring is the right call (almost always)
- Startups and small teams: operational complexity kills small teams. Default to managed services and proven stacks.
- Under time pressure: debugging unknown tech under deadline is brutal.
- Core infrastructure: databases, queues, auth — these need to be boring.
When new tech is worth it
- The boring alternative genuinely can't do the job (not just "does it less elegantly").
- You have team members with real production experience in it.
- The expected lifespan of this system justifies the learning investment.
- You've prototyped it and it behaved predictably under realistic conditions.
Key questions to surface
When helping someone with a tech decision, work through:
- What's the actual problem we're solving?
- What's the simplest thing that could possibly work?
- What do we already have that we could stretch?
- If we adopt this, who will be on call when it breaks at midnight?
- Are we choosing this for us, or for the engineers who come after us?
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

