10x Development Patterns (Meta-Skill)
Patterns that compress timelines, eliminate waste, and multiply output. These are the habits and systems that separate high-velocity teams from the rest.
Installation
OpenClaw / Moltbot / Clawbot
npx clawhub@latest install 10x-patterns
When to Use
- Starting a new project — set up the right foundations from day one
- Planning sprints — prioritize work that compounds
- Optimizing workflow — identify and remove bottlenecks
- Reviewing velocity — measure and improve throughput
- Onboarding developers — teach high-leverage habits
- Retrospectives — diagnose why things are slow
Core Principles
| Principle |
Description |
Example |
| Parallel execution |
Don't serialize independent tasks; run them concurrently |
Run linting, tests, and type-checking in parallel CI jobs |
| Early validation |
Validate assumptions before building |
Prototype the riskiest part first, not the easiest |
| Reuse over rebuild |
Leverage existing solutions before writing custom code |
Use shadcn/ui instead of building a component library |
| Automation first |
Automate any repetitive task on the second occurrence |
Script database seeding, not manual SQL inserts |
| Fail fast |
Catch errors at the earliest possible stage |
Strict TypeScript, pre-commit hooks, schema validation |
| Minimize context switching |
Batch similar work together |
Handle all PR reviews in one block, not scattered |
| Shortest feedback loop |
Reduce time between change and feedback |
Hot reload, preview deploys, co-located tests |
Development Velocity Patterns
| Pattern |
What It Does |
Speed Multiplier |
| Hot reload / fast refresh |
See changes instantly without losing state |
3-5x faster UI iteration |
| Type-driven development |
Define types/interfaces first, then implement |
Catches 40%+ of bugs at write time |
| Test-driven development |
Write tests for complex logic before implementation |
Fewer regressions, faster debugging |
| Feature flags |
Ship incomplete features safely behind toggles |
Continuous delivery without risk |
| Vertical slicing |
Build full-stack thin slices end-to-end |
Faster feedback, smaller PRs |
| Monorepo |
Share code, types, and config across packages |
Eliminates cross-repo sync overhead |
| Code generation |
Generate boilerplate from schemas or templates |
Minutes instead of hours for CRUD |
| AI-assisted development |
Use Cursor, Copilot for acceleration |
2-5x faster for boilerplate and exploration |
| Template repositories |
Start new projects from proven templates |
Skip setup entirely |
| Shared component libraries |
Reusable, tested UI building blocks |
Consistent UI, no re-implementation |
| Preview deployments |
Every PR gets a live URL (Vercel, Netlify) |
Instant stakeholder feedback |
| Trunk-based development |
Short-lived branches, frequent merges to main |
Eliminates merge hell |
| Continuous deployment |
Every merge to main auto-deploys |
Zero manual deploy overhead |
| Database migrations as code |
Version-controlled, repeatable schema changes |
No manual DB modifications |
| Infrastructure as code |
Terraform, Pulumi, SST for infra |
Reproducible environments in minutes |
| API-first design |
Define API contracts before implementation |
Frontend and backend work in parallel |
| Storybook / component dev |
Develop UI components in isolation |
No need to navigate full app for UI work |
Leverage Points
High effort-to-impact ratio — small investments that pay dividends repeatedly.
| Leverage Point |
Effort |
Impact |
Payoff Timeline |
| Automation scripts (seed, reset, deploy) |
1-2 hours |
Saves 10+ min/day per developer |
Days |
| Shared utilities (formatting, validation, logging) |
2-4 hours |
Eliminates repeated code across services |
Weeks |
| CI/CD pipelines |
4-8 hours |
Removes all manual build/deploy steps |
Immediately |
| Documentation (ADRs, onboarding, runbooks) |
2-3 hours |
Cuts onboarding time by 50%+ |
Weeks |
| Developer tooling (linters, formatters, git hooks) |
1-2 hours |
Prevents entire categories of bugs |
Immediately |
| Database seed scripts |
1-2 hours |
Instant realistic local environments |
Days |
| Error monitoring (Sentry, Axiom) |
1-2 hours |
Find production bugs before users report them |
Immediately |
Time Sink Detection
Common time wasters and how to eliminate them.
| Time Sink |
Hours Wasted/Week |
Solution |
| Manual testing |
3-8 hours |
Automated tests, Playwright for E2E, CI checks |
| Environment setup |
2-5 hours (new devs) |
Docker Compose, devcontainers, seed scripts |
| Manual deployment |
1-3 hours |
CI/CD pipeline, one-click deploys |
| Code review bottlenecks |
2-6 hours waiting |
Small PRs, async reviews, max 24h SLA |
| Meeting overload |
5-10 hours |
Async standups, written updates, office hours |
| Debugging without logs |
2-4 hours |
Structured logging, error tracking, source maps |
| Dependency conflicts |
1-3 hours |
Lock files, renovate bot, monorepo tooling |
| Unclear requirements |
3-8 hours rework |
Spike tickets, design docs, early prototypes |
Workflow Optimization
Daily Workflow Template
Morning (high energy)
1. Review overnight CI results and alerts
2. Tackle the hardest problem first (deep work)
3. Batch code reviews (one block, not scattered)
Midday
4. Meetings and collaboration (if unavoidable)
5. Respond to async threads
Afternoon
6. Implementation work (flow state)
7. Write tests for today's code
8. Open PRs, update tickets, write context for tomorrow
Essential IDE Shortcuts
| Action |
macOS |
Why It Matters |
| Go to file |
Cmd+P |
Never browse the file tree |
| Go to symbol |
Cmd+Shift+O |
Jump directly to functions/classes |
| Find in project |
Cmd+Shift+F |
Find anything across the codebase |
| Rename symbol |
F2 |
Safe, project-wide renaming |
| Quick fix |
Cmd+. |
Auto-import, auto-fix linter issues |
| Toggle terminal |
Ctrl+` |
Stay in the editor |
| Multi-cursor |
Cmd+D |
Edit multiple occurrences at once |
| Move line |
Alt+Up/Down |
Reorder code without cut/paste |
CLI Aliases & Scripts
# Git acceleration
alias gs='git status'
alias gc='git commit'
alias gp='git push'
alias gl='git log --oneline -20'
alias gco='git checkout'
alias gcb='git checkout -b'
alias gpr='gh pr create --fill'
# Development
alias dev='npm run dev'
alias build='npm run build'
alias lint='npm run lint'
alias test='npm run test'
# Docker
alias dc='docker compose'
alias dcu='docker compose up -d'
alias dcd='docker compose down'
alias dcl='docker compose logs -f'
# Project navigation
alias repo='cd ~/dev/myproject'
Shell Scripts Worth Writing
| Script |
Purpose |
Time Saved |
./scripts/setup.sh |
One-command local environment setup |
Hours per new dev |
./scripts/seed.sh |
Reset and seed database with test data |
10 min/day |
./scripts/deploy.sh |
Build, test, and deploy in sequence |
15 min/deploy |
./scripts/new-feature.sh |
Scaffold feature (route, component, test) |
20 min/feature |
./scripts/db-reset.sh |
Drop, recreate, migrate, seed database |
10 min/occurrence |
Anti-Patterns
Patterns that feel productive but destroy velocity.
| Anti-Pattern |
What Happens |
Instead Do |
| Over-engineering |
Build abstractions for problems you don't have |
Solve today's problem; refactor when patterns emerge |
| Premature optimization |
Optimize code that isn't a bottleneck |
Profile first, optimize the measured bottleneck |
| Gold plating |
Polish features beyond requirements |
Ship the 80% solution, iterate based on feedback |
| Yak shaving |
Fix tangential problems endlessly |
Time-box tangents to 15 min, then create a ticket |
| Not-invented-here |
Rebuild what open source already solved |
Evaluate existing solutions before writing custom code |
| Bikeshedding |
Debate trivial decisions at length |
Set a 5-min timer; if no consensus, the proposer decides |
| Cargo culting |
Copy patterns without understanding why |
Understand the problem before adopting a solution |
Measurement — DORA Metrics
Track these four metrics to objectively measure engineering velocity.
| Metric |
Elite |
High |
Medium |
Low |
| Deployment frequency |
On-demand (multiple/day) |
Weekly |
Monthly |
Quarterly |
| Lead time for changes |
< 1 hour |
< 1 week |
< 1 month |
> 1 month |
| Change failure rate |
< 5% |
< 10% |
< 15% |
> 15% |
| Mean time to recovery |
< 1 hour |
< 1 day |
< 1 week |
> 1 week |
How to Improve Each
- Deployment frequency — CI/CD, feature flags, trunk-based development
- Lead time — Small PRs, automated testing, preview deploys
- Change failure rate — Type safety, comprehensive tests, canary deploys
- MTTR — Observability, runbooks, feature flag kill switches
NEVER Do
- NEVER manually deploy to production — always use CI/CD pipelines
- NEVER merge without automated checks — require passing CI before merge
- NEVER keep long-lived feature branches — merge within 1-2 days or break it smaller
- NEVER skip writing types/interfaces — the 30 seconds you save costs hours later
- NEVER copy-paste code more than once — extract to a shared utility immediately
- NEVER ignore flaky tests — fix or delete them; flaky tests erode trust in the suite
- NEVER optimize without measuring — profile first, gut feelings are usually wrong
1---2name: 10x-patterns3description: Patterns and practices that dramatically accelerate development velocity. Covers parallel execution, automation, feedback loops, workflow optimization, and anti-pattern avoidance. Use when starting projects, planning sprints, optimizing workflows, or onboarding developers.4---5
6# 10x Development Patterns (Meta-Skill)
7
8Patterns that compress timelines, eliminate waste, and multiply output. These are the habits and systems that separate high-velocity teams from the rest.
9
10
11## Installation
12
13### OpenClaw / Moltbot / Clawbot
14
15```bash
16npx clawhub@latest install 10x-patterns
17```
18
19
20---
21
22## When to Use
23
24- Starting a new project — set up the right foundations from day one
25- Planning sprints — prioritize work that compounds
26- Optimizing workflow — identify and remove bottlenecks
27- Reviewing velocity — measure and improve throughput
28- Onboarding developers — teach high-leverage habits
29- Retrospectives — diagnose why things are slow
30
31---
32
33## Core Principles
34
35| Principle | Description | Example |
36|---|---|---|
37| Parallel execution | Don't serialize independent tasks; run them concurrently | Run linting, tests, and type-checking in parallel CI jobs |
38| Early validation | Validate assumptions before building | Prototype the riskiest part first, not the easiest |
39| Reuse over rebuild | Leverage existing solutions before writing custom code | Use shadcn/ui instead of building a component library |
40| Automation first | Automate any repetitive task on the second occurrence | Script database seeding, not manual SQL inserts |
41| Fail fast | Catch errors at the earliest possible stage | Strict TypeScript, pre-commit hooks, schema validation |
42| Minimize context switching | Batch similar work together | Handle all PR reviews in one block, not scattered |
43| Shortest feedback loop | Reduce time between change and feedback | Hot reload, preview deploys, co-located tests |
44
45---
46
47## Development Velocity Patterns
48
49| Pattern | What It Does | Speed Multiplier |
50|---|---|---|
51| Hot reload / fast refresh | See changes instantly without losing state | 3-5x faster UI iteration |
52| Type-driven development | Define types/interfaces first, then implement | Catches 40%+ of bugs at write time |
53| Test-driven development | Write tests for complex logic before implementation | Fewer regressions, faster debugging |
54| Feature flags | Ship incomplete features safely behind toggles | Continuous delivery without risk |
55| Vertical slicing | Build full-stack thin slices end-to-end | Faster feedback, smaller PRs |
56| Monorepo | Share code, types, and config across packages | Eliminates cross-repo sync overhead |
57| Code generation | Generate boilerplate from schemas or templates | Minutes instead of hours for CRUD |
58| AI-assisted development | Use Cursor, Copilot for acceleration | 2-5x faster for boilerplate and exploration |
59| Template repositories | Start new projects from proven templates | Skip setup entirely |
60| Shared component libraries | Reusable, tested UI building blocks | Consistent UI, no re-implementation |
61| Preview deployments | Every PR gets a live URL (Vercel, Netlify) | Instant stakeholder feedback |
62| Trunk-based development | Short-lived branches, frequent merges to main | Eliminates merge hell |
63| Continuous deployment | Every merge to main auto-deploys | Zero manual deploy overhead |
64| Database migrations as code | Version-controlled, repeatable schema changes | No manual DB modifications |
65| Infrastructure as code | Terraform, Pulumi, SST for infra | Reproducible environments in minutes |
66| API-first design | Define API contracts before implementation | Frontend and backend work in parallel |
67| Storybook / component dev | Develop UI components in isolation | No need to navigate full app for UI work |
68
69---
70
71## Leverage Points
72
73High effort-to-impact ratio — small investments that pay dividends repeatedly.
74
75| Leverage Point | Effort | Impact | Payoff Timeline |
76|---|---|---|---|
77| Automation scripts (seed, reset, deploy) | 1-2 hours | Saves 10+ min/day per developer | Days |
78| Shared utilities (formatting, validation, logging) | 2-4 hours | Eliminates repeated code across services | Weeks |
79| CI/CD pipelines | 4-8 hours | Removes all manual build/deploy steps | Immediately |
80| Documentation (ADRs, onboarding, runbooks) | 2-3 hours | Cuts onboarding time by 50%+ | Weeks |
81| Developer tooling (linters, formatters, git hooks) | 1-2 hours | Prevents entire categories of bugs | Immediately |
82| Database seed scripts | 1-2 hours | Instant realistic local environments | Days |
83| Error monitoring (Sentry, Axiom) | 1-2 hours | Find production bugs before users report them | Immediately |
84
85---
86
87## Time Sink Detection
88
89Common time wasters and how to eliminate them.
90
91| Time Sink | Hours Wasted/Week | Solution |
92|---|---|---|
93| Manual testing | 3-8 hours | Automated tests, Playwright for E2E, CI checks |
94| Environment setup | 2-5 hours (new devs) | Docker Compose, devcontainers, seed scripts |
95| Manual deployment | 1-3 hours | CI/CD pipeline, one-click deploys |
96| Code review bottlenecks | 2-6 hours waiting | Small PRs, async reviews, max 24h SLA |
97| Meeting overload | 5-10 hours | Async standups, written updates, office hours |
98| Debugging without logs | 2-4 hours | Structured logging, error tracking, source maps |
99| Dependency conflicts | 1-3 hours | Lock files, renovate bot, monorepo tooling |
100| Unclear requirements | 3-8 hours rework | Spike tickets, design docs, early prototypes |
101
102---
103
104## Workflow Optimization
105
106### Daily Workflow Template
107
108```
109Morning (high energy)
110 1. Review overnight CI results and alerts
111 2. Tackle the hardest problem first (deep work)
112 3. Batch code reviews (one block, not scattered)
113
114Midday
115 4. Meetings and collaboration (if unavoidable)
116 5. Respond to async threads
117
118Afternoon
119 6. Implementation work (flow state)
120 7. Write tests for today's code
121 8. Open PRs, update tickets, write context for tomorrow
122```
123
124### Essential IDE Shortcuts
125
126| Action | macOS | Why It Matters |
127|---|---|---|
128| Go to file | `Cmd+P` | Never browse the file tree |
129| Go to symbol | `Cmd+Shift+O` | Jump directly to functions/classes |
130| Find in project | `Cmd+Shift+F` | Find anything across the codebase |
131| Rename symbol | `F2` | Safe, project-wide renaming |
132| Quick fix | `Cmd+.` | Auto-import, auto-fix linter issues |
133| Toggle terminal | `` Ctrl+` `` | Stay in the editor |
134| Multi-cursor | `Cmd+D` | Edit multiple occurrences at once |
135| Move line | `Alt+Up/Down` | Reorder code without cut/paste |
136
137### CLI Aliases & Scripts
138
139```bash
140# Git acceleration
141alias gs='git status'
142alias gc='git commit'
143alias gp='git push'
144alias gl='git log --oneline -20'
145alias gco='git checkout'
146alias gcb='git checkout -b'
147alias gpr='gh pr create --fill'
148
149# Development
150alias dev='npm run dev'
151alias build='npm run build'
152alias lint='npm run lint'
153alias test='npm run test'
154
155# Docker
156alias dc='docker compose'
157alias dcu='docker compose up -d'
158alias dcd='docker compose down'
159alias dcl='docker compose logs -f'
160
161# Project navigation
162alias repo='cd ~/dev/myproject'
163```
164
165### Shell Scripts Worth Writing
166
167| Script | Purpose | Time Saved |
168|---|---|---|
169| `./scripts/setup.sh` | One-command local environment setup | Hours per new dev |
170| `./scripts/seed.sh` | Reset and seed database with test data | 10 min/day |
171| `./scripts/deploy.sh` | Build, test, and deploy in sequence | 15 min/deploy |
172| `./scripts/new-feature.sh` | Scaffold feature (route, component, test) | 20 min/feature |
173| `./scripts/db-reset.sh` | Drop, recreate, migrate, seed database | 10 min/occurrence |
174
175---
176
177## Anti-Patterns
178
179Patterns that feel productive but destroy velocity.
180
181| Anti-Pattern | What Happens | Instead Do |
182|---|---|---|
183| Over-engineering | Build abstractions for problems you don't have | Solve today's problem; refactor when patterns emerge |
184| Premature optimization | Optimize code that isn't a bottleneck | Profile first, optimize the measured bottleneck |
185| Gold plating | Polish features beyond requirements | Ship the 80% solution, iterate based on feedback |
186| Yak shaving | Fix tangential problems endlessly | Time-box tangents to 15 min, then create a ticket |
187| Not-invented-here | Rebuild what open source already solved | Evaluate existing solutions before writing custom code |
188| Bikeshedding | Debate trivial decisions at length | Set a 5-min timer; if no consensus, the proposer decides |
189| Cargo culting | Copy patterns without understanding why | Understand the problem before adopting a solution |
190
191---
192
193## Measurement — DORA Metrics
194
195Track these four metrics to objectively measure engineering velocity.
196
197| Metric | Elite | High | Medium | Low |
198|---|---|---|---|---|
199| **Deployment frequency** | On-demand (multiple/day) | Weekly | Monthly | Quarterly |
200| **Lead time for changes** | < 1 hour | < 1 week | < 1 month | > 1 month |
201| **Change failure rate** | < 5% | < 10% | < 15% | > 15% |
202| **Mean time to recovery** | < 1 hour | < 1 day | < 1 week | > 1 week |
203
204### How to Improve Each
205
206- **Deployment frequency** — CI/CD, feature flags, trunk-based development
207- **Lead time** — Small PRs, automated testing, preview deploys
208- **Change failure rate** — Type safety, comprehensive tests, canary deploys
209- **MTTR** — Observability, runbooks, feature flag kill switches
210
211---
212
213## NEVER Do
214
2151. **NEVER manually deploy to production** — always use CI/CD pipelines
2162. **NEVER merge without automated checks** — require passing CI before merge
2173. **NEVER keep long-lived feature branches** — merge within 1-2 days or break it smaller
2184. **NEVER skip writing types/interfaces** — the 30 seconds you save costs hours later
2195. **NEVER copy-paste code more than once** — extract to a shared utility immediately
2206. **NEVER ignore flaky tests** — fix or delete them; flaky tests erode trust in the suite
2217. **NEVER optimize without measuring** — profile first, gut feelings are usually wrong
modbender