Week 4: From Completion to Iteration - VoidPad Ships and AI Workflows Evolve

Jun 23, 2025 7 min

Week four marked a fascinating transition from building to using, from exploring new tools to refining workflows, and from the excitement of creation to the discipline of daily practice. After battling through a stinking cold at the beginning of the week, I celebrated completing VoidPad’s first iteration whilst finding my way back to familiar development workflows enhanced by new AI capabilities.

Adam Wathan’s excellent video on AI coding perfectly captured something I’ve been feeling: AI is a force multiplier for experts, but not a substitute for learning. It’s a distinction that matters more than most people realise.

The Great Editor Migration: From Cursor Back to Neovim

After a decade of unwavering Neovim loyalty, I thought nothing could tempt me away from my carefully crafted configuration. Then Cursor happened—its agentic workflows were compelling enough to break a ten-year habit. But something felt off. The power was there, but it came at the cost of the fluid, keyboard-driven experience that made coding feel like thought made manifest.

Enter Claude Code. Suddenly, I could have the best of both worlds: sophisticated AI assistance without sacrificing the editor that feels like an extension of my nervous system. The transition back to Neovim felt like coming home, but with a powerful new companion.

The difference is philosophical: Cursor tries to be your entire development environment, whilst Claude Code augments your existing workflow. The distinction matters more than I initially realised. When your editor is fighting your muscle memory, every interaction becomes conscious effort rather than unconscious flow.

This experience reinforced Adam Wathan’s point about AI as “keyboard shortcuts on steroids” for experts. The value isn’t in replacing your expertise—it’s in eliminating the friction between intention and implementation.

VoidPad: From Development to Daily Use

This week marked a significant milestone: completing VoidPad’s first iteration following the “Simple, Loveable, Complete” (SLC) principle and transitioning from developer to daily user. After discovering the original “VoidNote” name was taken, we returned to “VoidPad”—sometimes the simplest solutions are the most elegant.

The project reached a fascinating inflection point where building stopped and using began. This transition from creator to consumer provides invaluable perspective on what actually matters in software design.

Mobile Platform Progress

VoidPad Mobile Statistics:

  • Total Commits: 19
  • New Features: 6 commits
  • Improvements & Refactoring: 4 commits
  • Bug Fixes: 3 commits
  • Configuration Updates: 6 commits

The week’s major achievements included implementing keyboard-aware views for seamless note-taking, adding tablet support for iOS, and integrating both Sentry for error tracking and PostHog for analytics. The keyboard handling refactoring across Notes, SignIn, and SignUp screens particularly improved the user experience—those small interaction details that users feel but rarely articulate.

Desktop Platform Evolution

VoidPad Desktop Statistics:

  • Total Commits: 43
  • New Features: 21 commits
  • Improvements & Refactoring: 14 commits
  • Bug Fixes: 8 commits

Desktop development focused heavily on user experience refinements: a macOS System Preferences-style settings interface, launch-on-startup functionality, and enhanced onboarding with a carousel component. The ContextMenu integration and global keybinding system refactoring particularly improved daily usability.

The Psychology of Shipping

There’s something profound about the moment when you stop tweaking and start trusting your work enough to use it daily. VoidPad has reached that threshold—not perfect, but complete enough to solve real problems. The next few weeks of personal usage will reveal which features actually matter and which were merely interesting to build.

This aligns with Adam Wathan’s observation that professional developers solve practical problems for people with code. We’re not artisans crafting perfect objects, but engineers creating useful tools. VoidPad’s value will be measured by how effectively it captures and retrieves thoughts, not by the elegance of its architecture.

Komitto: The Art of Incremental Improvement

With VoidPad transitioning to daily use, attention shifted to Komitto’s evolution. The focus this week was entirely practical: making missed tasks visible and actionable.

Komitto Statistics:

  • Total Commits: 11
  • New Features: 6 commits (primarily missed tasks functionality)
  • Improvements & Refactoring: 2 commits
  • Bug Fixes: 3 commits

The missed tasks feature represents a perfect example of how small changes can dramatically improve user experience. Adding cross icons for visibility, enhancing challenge statistics, and replacing today’s completion rate with missed task counts all serve one goal: helping users understand where they’re falling short without making them feel defeated.

The bug fixes—aligning track status calculations and resolving require cycles—demonstrate the ongoing discipline required to maintain code quality whilst adding features. These aren’t glamorous commits, but they’re essential for sustainable development.

Breedr: Mature Codebase Evolution

Breedr’s development this week exemplified how established codebases require different approaches than greenfield projects. The new chute API integration, beep functionality for unrecognised animals, and enhanced GraphQL schema all built upon existing foundations rather than reimagining core concepts.

Breedr Statistics:

  • Total Commits: 29
  • New Features: 9 commits
  • Improvements & Refactoring: 4 commits
  • Bug Fixes: 3 commits

The beep functionality for unrecognised animals perfectly illustrates practical problem-solving. Rather than building complex identification systems, sometimes the best solution is simply alerting users when something unexpected happens. This kind of pragmatic feature design becomes more common as products mature and real-world usage patterns emerge.

AI Orchestration vs Handwriting

The most significant conceptual shift this week came from exploring different AI-assisted development workflows. The conversation on Claude Code from Anthropic particularly resonated: embrace the shift from handwriting to orchestrating.

This isn’t about writing less code—it’s about writing more intentional code. When AI handles boilerplate generation, configuration management, and repetitive patterns, human attention can focus on architecture decisions, user experience considerations, and the creative problem-solving that actually differentiates products.

The key insight: AI excels at translating clear intentions into working code, but those intentions still require human insight, domain knowledge, and empathy for users.

The Dogfooding Philosophy

This week reinforced the importance of dogfooding—using your own products daily to understand their real strengths and weaknesses. VoidPad’s transition from development project to daily tool has already revealed assumptions that need questioning:

  • Note organisation: Complex hierarchies matter less than fast capture and retrieval
  • Cross-device sync: Seamless background synchronisation trumps manual sync controls
  • Formatting: Smart paste handling eliminates more friction than rich text editing

These insights only emerge through actual usage, not theoretical analysis. The best product decisions come from experiencing your own pain points, not from imagining user scenarios.

The Philosophy of “Almost Working”

Adam Wathan’s observation about AI dropping you at “that golden moment where shit almost works” perfectly captures why these tools feel so powerful. The dopamine hit of iterative improvement—tweaking code and immediately seeing better results—is fundamental to why many of us chose software engineering.

AI tools amplify this experience by eliminating the tedious setup work that delays gratification. Instead of spending hours on boilerplate before reaching the interesting problems, AI gets you to the satisfying iteration phase immediately.

This psychological dimension of developer experience often gets overlooked in productivity discussions, but it’s crucial for sustainable engineering practices. Tools that preserve the joy of programming whilst eliminating drudgery are more likely to see long-term adoption than those that optimise purely for output metrics.

Looking Forward

As we enter week five, several themes are crystallising:

Tool Mastery: The combination of Neovim and Claude Code is proving more powerful than either alone, suggesting that AI augmentation works best when it respects existing workflows rather than replacing them.

Product Maturity: VoidPad’s transition to daily use will provide real-world feedback that theoretical analysis couldn’t reveal. The gap between “feature complete” and “actually useful” is often wider than anticipated.

Sustainable Development: The balance between AI assistance and human insight requires constant calibration. The goal isn’t to eliminate human involvement, but to focus it where it adds most value.

Team Evolution: As AI tools become more sophisticated, the key differentiator for engineering teams will be how effectively they integrate these capabilities with human expertise and domain knowledge.

Next week promises continued iteration based on real usage patterns, further refinement of AI-assisted workflows, and the inevitable emergence of new challenges that will test these philosophical approaches against practical constraints.

Remember: the most valuable engineering insights often come from the intersection of theoretical understanding and daily practice. This week reinforced that building is only half the equation—using what you build teaches you what actually matters.

~James Best