Coding

10x Patterns

Try it

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.

What it does

Patterns that compress timelines, eliminate waste, and multiply output. These are the habits and systems that separate high-velocity teams from the rest.

The skill document

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

PrincipleDescriptionExample
Parallel executionDon't serialize independent tasks; run them concurrentlyRun linting, tests, and type-checking in parallel CI jobs
Early validationValidate assumptions before buildingPrototype the riskiest part first, not the easiest
Reuse over rebuildLeverage existing solutions before writing custom codeUse shadcn/ui instead of building a component library
Automation firstAutomate any repetitive task on the second occurrenceScript database seeding, not manual SQL inserts
Fail fastCatch errors at the earliest possible stageStrict TypeScript, pre-commit hooks, schema validation
Minimize context switchingBatch similar work togetherHandle all PR reviews in one block, not scattered
Shortest feedback loopReduce time between change and feedbackHot reload, preview deploys, co-located tests

Development Velocity Patterns

PatternWhat It DoesSpeed Multiplier
Hot reload / fast refreshSee changes instantly without losing state3-5x faster UI iteration
Type-driven developmentDefine types/interfaces first, then implementCatches 40%+ of bugs at write time
Test-driven developmentWrite tests for complex logic before implementationFewer regressions, faster debugging
Feature flagsShip incomplete features safely behind togglesContinuous delivery without risk
Vertical slicingBuild full-stack thin slices end-to-endFaster feedback, smaller PRs
MonorepoShare code, types, and config across packagesEliminates cross-repo sync overhead
Code generationGenerate boilerplate from schemas or templatesMinutes instead of hours for CRUD
AI-assisted developmentUse Cursor, Copilot for acceleration2-5x faster for boilerplate and exploration
Template repositoriesStart new projects from proven templatesSkip setup entirely
Shared component librariesReusable, tested UI building blocksConsistent UI, no re-implementation
Preview deploymentsEvery PR gets a live URL (Vercel, Netlify)Instant stakeholder feedback
Trunk-based developmentShort-lived branches, frequent merges to mainEliminates merge hell
Continuous deploymentEvery merge to main auto-deploysZero manual deploy overhead
Database migrations as codeVersion-controlled, repeatable schema changesNo manual DB modifications
Infrastructure as codeTerraform, Pulumi, SST for infraReproducible environments in minutes
API-first designDefine API contracts before implementationFrontend and backend work in parallel
Storybook / component devDevelop UI components in isolationNo need to navigate full app for UI work

Leverage Points

High effort-to-impact ratio — small investments that pay dividends repeatedly.

Leverage PointEffortImpactPayoff Timeline
Automation scripts (seed, reset, deploy)1-2 hoursSaves 10+ min/day per developerDays
Shared utilities (formatting, validation, logging)2-4 hoursEliminates repeated code across servicesWeeks
CI/CD pipelines4-8 hoursRemoves all manual build/deploy stepsImmediately
Documentation (ADRs, onboarding, runbooks)2-3 hoursCuts onboarding time by 50%+Weeks
Developer tooling (linters, formatters, git hooks)1-2 hoursPrevents entire categories of bugsImmediately
Database seed scripts1-2 hoursInstant realistic local environmentsDays
Error monitoring (Sentry, Axiom)1-2 hoursFind production bugs before users report themImmediately

Time Sink Detection

Common time wasters and how to eliminate them.

Time SinkHours Wasted/WeekSolution
Manual testing3-8 hoursAutomated tests, Playwright for E2E, CI checks
Environment setup2-5 hours (new devs)Docker Compose, devcontainers, seed scripts
Manual deployment1-3 hoursCI/CD pipeline, one-click deploys
Code review bottlenecks2-6 hours waitingSmall PRs, async reviews, max 24h SLA
Meeting overload5-10 hoursAsync standups, written updates, office hours
Debugging without logs2-4 hoursStructured logging, error tracking, source maps
Dependency conflicts1-3 hoursLock files, renovate bot, monorepo tooling
Unclear requirements3-8 hours reworkSpike 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

ActionmacOSWhy It Matters
Go to fileCmd+PNever browse the file tree
Go to symbolCmd+Shift+OJump directly to functions/classes
Find in projectCmd+Shift+FFind anything across the codebase
Rename symbolF2Safe, project-wide renaming
Quick fixCmd+.Auto-import, auto-fix linter issues
Toggle terminalCtrl+`Stay in the editor
Multi-cursorCmd+DEdit multiple occurrences at once
Move lineAlt+Up/DownReorder 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

ScriptPurposeTime Saved
./scripts/setup.shOne-command local environment setupHours per new dev
./scripts/seed.shReset and seed database with test data10 min/day
./scripts/deploy.shBuild, test, and deploy in sequence15 min/deploy
./scripts/new-feature.shScaffold feature (route, component, test)20 min/feature
./scripts/db-reset.shDrop, recreate, migrate, seed database10 min/occurrence

Anti-Patterns

Patterns that feel productive but destroy velocity.

Anti-PatternWhat HappensInstead Do
Over-engineeringBuild abstractions for problems you don't haveSolve today's problem; refactor when patterns emerge
Premature optimizationOptimize code that isn't a bottleneckProfile first, optimize the measured bottleneck
Gold platingPolish features beyond requirementsShip the 80% solution, iterate based on feedback
Yak shavingFix tangential problems endlesslyTime-box tangents to 15 min, then create a ticket
Not-invented-hereRebuild what open source already solvedEvaluate existing solutions before writing custom code
BikesheddingDebate trivial decisions at lengthSet a 5-min timer; if no consensus, the proposer decides
Cargo cultingCopy patterns without understanding whyUnderstand the problem before adopting a solution

Measurement — DORA Metrics

Track these four metrics to objectively measure engineering velocity.

MetricEliteHighMediumLow
Deployment frequencyOn-demand (multiple/day)WeeklyMonthlyQuarterly
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

  1. NEVER manually deploy to production — always use CI/CD pipelines
  2. NEVER merge without automated checks — require passing CI before merge
  3. NEVER keep long-lived feature branches — merge within 1-2 days or break it smaller
  4. NEVER skip writing types/interfaces — the 30 seconds you save costs hours later
  5. NEVER copy-paste code more than once — extract to a shared utility immediately
  6. NEVER ignore flaky tests — fix or delete them; flaky tests erode trust in the suite
  7. NEVER optimize without measuring — profile first, gut feelings are usually wrong

Related skills

Find why your productivity system keeps failing, then apply the smallest fix — capacity math, bottleneck routing, durable local notes.

by Iván854 installs69 stars

figma-use

Official

Execute Plugin API JavaScript in Figma files to read, create, and modify nodes through `use_figma`.

by OpenAI27.5k stars

Build new agent skills from scratch and refine existing ones through an eval-driven test-and-iterate loop.

by Anthropic177.3k stars

cli-creator

Official

Scaffold a durable CLI with composable commands, stable JSON output, and auth handling that Codex can run from any repo.

by OpenAI27.5k stars

aspnet-core

Official

Get framework-current ASP.NET Core guidance for selecting app models, building pipelines, and writing idiomatic code.

by OpenAI27.5k stars

More from wpank

Browse all skills

Systematic code review patterns covering security, performance, maintainability, correctness, and testing — with severity levels, structured feedback guidance, review process, and anti-patterns to avoid. Use when reviewing PRs, establishing review standards, or improving review quality.

by wpank554 installs20 stars

Pragmatic coding standards for writing clean, maintainable code — naming, functions, structure, anti-patterns, and pre-edit safety checks. Use when writing new code, refactoring existing code, reviewing code quality, or establishing coding standards.

by wpank198 installs6 stars

Build reliable, fast E2E test suites with Playwright and Cypress. Critical user journey coverage, flaky test elimination, CI/CD integration.

by wpank336 installs6 stars

Build scalable, themable Tailwind CSS component libraries using CVA for variants, compound components, design tokens, dark mode, and responsive grids.

by wpank217 installs9 stars

Create software diagrams using Mermaid syntax. Use when users need to create, visualize, or document software through diagrams including class diagrams, sequence diagrams, flowcharts, ERDs, C4 architecture diagrams, state diagrams, git graphs, and other diagram types. Triggers include requests to diagram, visualize, model, map out, or show the flow of a system.

by wpank250 installs5 stars

Provides backend architecture patterns (Clean Architecture, Hexagonal, DDD) for building maintainable, testable, and scalable systems with clear layering and...

by wpank152 installs7 stars