Velocity Isn't Speed
Development velocity isn't typing speed or hours worked. It's rate of progress toward meaningful outcomes. You can work fast and accomplish little. You can work deliberately and accomplish much.
Methodology--the patterns, practices, and systems you use--determines velocity. The right methodology amplifies effort. The wrong methodology creates friction.
This chapter examines what accelerates development velocity, particularly when working with AI tools and ADHD-style cognition.
The ADHD Advantage in Development
ADHD is often framed as a deficit. In software development, it can be an advantage:
Hyperfocus: When engaged, ADHD brains can sustain intense concentration for hours. This is exactly what complex implementation requires.
Pattern recognition: ADHD brains excel at seeing patterns and connections across domains. This is where innovative solutions come from.
Impatience with tedium: ADHD brains push toward automation and tooling. Manual repetition is intolerable, so you build systems to eliminate it.
Rapid context switching ability: Paradoxically, the same brain that loses track of context can switch between contexts rapidly when motivated.
The key: designing workflows that leverage these traits instead of fighting them.
Infrastructure-First Development
The "build the thing that builds the thing" philosophy accelerates everything downstream:
Templates: Create templates for repeated structures. New components start from working patterns, not blank files.
Generators: Automate repetitive code generation. Define once, generate many times.
Checklist-driven processes: Document processes as checklists. Follow them every time. Catch what memory misses.
Decision logs: Record why you made choices. Future you (or the AI assistant) can reference them.
Reusable components: Extract common patterns. Solve each problem once, reuse the solution.
Time invested in infrastructure compounds. One hour building a generator that saves 10 minutes per use pays off after six uses--and continues paying forever.
AI-Assisted Velocity
AI coding assistants transform development velocity when used well:
Problem decomposition: Describe what you're building. Let the AI help break it into steps.
Implementation scaffolding: Get first-draft implementations quickly. Iterate from working code, not blank screens.
Knowledge retrieval: Query documentation, patterns, and prior work. Don't reinvent what exists.
Rubber ducking: Explain the problem to the AI. Often the explanation clarifies your thinking.
Code review: Have AI review your implementation. Catch issues you'd miss.
The key insight: AI doesn't replace thinking. It accelerates the feedback loop between thinking and implementation.
Session Structure for Velocity
How you structure work sessions affects velocity:
Clear session goals: Start each session knowing what "done" looks like. Vague sessions produce vague results.
Context loading: Begin by reviewing relevant context. State files, recent decisions, current blockers. Don't start cold.
Focus blocks: Protect time for deep work. Notifications off, interruptions blocked.
Transition rituals: When switching tasks, explicitly close out the previous context. Document state. Clear mental workspace.
Capture as you go: Write down insights and decisions as they occur. Don't trust memory.
Session closing: End with documentation. What was accomplished? What's next? Leave breadcrumbs for future sessions.
This structure compensates for working memory limits. External systems hold what your brain can't.
Managing Scope Creep
ADHD brains are prone to scope creep--each interesting tangent leads to three more. This is both a superpower (connections!) and a trap (nothing finishes).
Define scope explicitly: Write down what's in scope and out of scope before starting.
Parking lot: When tangents arise, note them and return to scope. Don't follow every thread.
Minimum viable progress: What's the smallest step that advances the goal? Do that.
Time boxes: Allocate fixed time to tasks. When time expires, ship what you have or consciously extend.
External accountability: Tell someone what you're working on. The social pressure helps maintain focus.
Scope management isn't about ignoring interesting tangents. It's about choosing when to pursue them.
Knowledge Reuse Patterns
Velocity compounds when you reuse knowledge:
Pattern libraries: Document patterns you've used successfully. Reference them when facing similar problems.
Snippet collections: Common code snippets, ready to paste. Don't retype boilerplate.
Decision templates: Standard structures for common decisions. Fill in the blanks, don't design from scratch.
Error catalogues: Document errors you've encountered and their solutions. When errors recur, the solution is ready.
Prior art search: Before building, search for existing solutions. Inside your codebase, in open source, in documentation.
Every problem you solve is a solved problem. Make that knowledge findable.
Cross-Domain Synthesis
Some of the highest-velocity insights come from applying patterns across domains:
Recognize structural similarity: Problems in different domains often share structure. Once you see the structure, solutions transfer.
Port solutions deliberately: When you solve something in one context, ask: where else does this pattern apply?
Maintain diverse input: Read widely. Work on varied projects. The raw material for synthesis comes from breadth.
Document connections: When you see a cross-domain pattern, write it down. Future you might not notice it again.
ADHD pattern recognition excels here. The wandering attention that visits many domains builds the library of patterns that enables synthesis.
Measuring Velocity
You can't improve what you don't measure:
Cycle time: How long from starting a task to completing it?
Deploy frequency: How often do changes ship?
Work item throughput: How many meaningful items completed per period?
Context switching count: How many task switches per session? Fewer is often better.
Unplanned work ratio: How much planned work versus reactive interruptions?
Don't measure for measurement's sake. Measure to identify bottlenecks. Address the bottlenecks. Measure again.
Sustainable Velocity
Velocity that can't be sustained isn't really velocity. It's a sprint followed by recovery.
Pace that works: Find a pace you can maintain indefinitely. Slightly below maximum is often optimal.
Recovery built in: Rest isn't wasted time. It's when consolidation happens.
Variety: Pure coding sessions exhaust differently than mixed sessions. Vary the work.
Boundaries: Work time is work time. Non-work time is non-work time. Blur at your peril.
Continuous improvement: Small efficiency gains compound. 1% better each week is substantial over a year.
ADHD brains can sprint intensely. Sustainability comes from building systems that don't require constant sprinting.
The Compound Effect
Individual velocity improvements are nice. The compound effect is transformative.
Better methodology + AI tools + knowledge infrastructure + ADHD traits = multiplicative acceleration.
Each factor amplifies the others:
- Methodology makes AI tools more effective
- Knowledge infrastructure feeds AI with relevant context
- ADHD pattern recognition finds connections others miss
- The connections feed back into methodology improvements
This is what infrastructure thinking enables at the personal level. Build the systems that build your capability.
Related: D4 explores hyperfocus specifically. C3 covers the knowledge graph productivity angle.