Week 2: Sleep, Scripts, and the Philosophy of Simple Solutions • James Best

Welcome back to week two of my engineering rundowns. If last week was about finding rhythm between personal projects and production polish, this week has been about confronting the realities of sustainable engineering practice—particularly when your sleep patterns decide to rebel against you.

There’s something brutally honest about how poor sleep exposes the gaps in our engineering workflows. When your cognitive capacity is reduced, you quickly discover which processes are genuinely helpful and which are just ceremony. This week’s challenges became an unexpected lens for examining how we build, review, and iterate on software.

The MVP Fatigue Syndrome

The most thought-provoking read this week came from an article challenging the sacred cow of MVP development. The author argued for “SLC” instead—Simple, Lovable, and Complete—rather than the traditional Minimum Viable Product approach.

The quote that stuck with me: “With SLC, the outcomes are better and your options for next steps are better. It might fail; both SLCs and MVPs sometimes produce that result because you’re running an experiment. But if a SLC succeeds, you’ve already delivered real value to customers and you have multiple futures available to you, none of which are urgent.”

As an Lead Engineer, I’ve witnessed the MVP trap firsthand. Teams ship the absolute minimum, then spend months retrofitting quality, usability, and completeness. The technical debt compounds faster than the learning velocity, and you end up with products that feel apologetic rather than confident.

The SLC philosophy resonates because it acknowledges that users don’t experience “minimum”—they experience your product as a complete entity. A simple, lovable, complete experience creates better feedback loops than a barely-functional proof of concept.

Read it here

Automation as Cognitive Scaffolding

Getting less sleep than usual this week pushed me to rely more on automation, which led to some interesting discoveries. When you’re running on less mental bandwidth, well-designed tools become essential rather than just nice-to-have.

I’ve been refining a collection of shell scripts that handle the cognitive overhead of common development tasks:

The Repomix Enhancement: One of the most powerful additions to my workflow has been a wrapper script around Repomix—a CLI tool that packages entire codebases into AI-friendly formats. Repomix itself is brilliant: it takes your repository and creates a single XML, Markdown, or plain text file that contains your entire codebase, complete with token counting for LLM context limits and security scanning to prevent accidentally sharing sensitive information.

My enhancement adds interactive file selection using fzf (fuzzy finder), transforming a command-line tool into an intuitive interface. The script provides four distinct modes: whole directory packing, include-only mode for focusing on specific files, ignore mode for excluding particular paths, and a combined mode for precise control over both inclusions and exclusions.

What makes this particularly valuable for AI-assisted development is the precision it enables. Instead of dumping an entire codebase into an AI conversation, I can interactively select exactly the relevant files for the task at hand. When reviewing a complex React Native component, for instance, I can quickly select the component file, its tests, related utilities, and type definitions—creating a focused context that maximises the AI’s ability to provide meaningful insights without hitting token limits.

The tool respects Git conventions automatically, uses fd when available for performance, and intelligently falls back through git ls-files to regular find commands. The result is copied directly to clipboard, making the workflow from “I need to analyse this code” to “here’s the context” nearly frictionless.

Git Summary Automation: Rather than a simple commit log parser, this has evolved into a comprehensive Git analysis system that transforms the chaos of daily commits into structured insights. The script analyses commits across all branches for the current Git user, automatically categorising them into logical groups: New Features, Bug Fixes, Improvements & Refactoring, Updates, Cleanup, Documentation, Testing, and Other Changes.

What sets this apart from basic Git tooling is its intelligence around timeframes and scope. It supports flexible time ranges—today, yesterday, this week, or custom periods—and can process multiple repositories in a single run. The tool includes interactive discovery of Git repositories in common directories, using fzf for fuzzy selection when available, with graceful fallbacks to numbered menus.

The integration with AI tooling via the fabric framework elevates this from simple categorisation to genuine insight generation. After parsing and organising commits, the script can generate enhanced summaries that provide context about development patterns, productivity trends, and project momentum. The output format groups commits by category, highlights recent changes (particularly those from the last 24 hours), and provides statistical breakdowns.

For engineering managers, this tool bridges the gap between granular commit data and the higher-level reporting needed for standups, sprint reviews, and progress communication. Instead of manually reconstructing what happened across multiple projects over complex timeframes, the script handles the mechanical analysis and leaves space for strategic interpretation. This very blog post series relies on this automation to transform weeks of scattered development work into coherent narratives.

Frictionless Note-Taking: Discovered Antinote.io this week—a beautifully simple tool for throwaway notes. Sometimes the best productivity tool is the one that gets out of your way entirely.

The common thread across these tools isn’t just efficiency—it’s cognitive scaffolding. They handle the mechanical aspects of information gathering and organisation, freeing mental capacity for the creative and analytical work that requires human insight.

AI-Assisted Code Review Evolution

The most substantial development this week was expanding my AI-assisted code review tool. What started as a simple diff analyser has evolved into a modular system that can:

Generate contextual prompts based on project type (React Native, general web, etc.)
Chunk large diffs intelligently for thorough analysis
Post comments directly to GitHub PRs
Format responses for easy consumption by AI agents

The tool now includes a “problem-solving prompt” specifically designed for React Native projects, acknowledging that mobile development has unique constraints and patterns that generic code review tools often miss.

But the most valuable insight came from using this tool on my own code before submitting for human review. There’s something powerful about having an AI agent identify potential issues with your implementation, then using another AI agent to fix them based on the review comments. It’s not replacing human judgement—it’s creating a more thoughtful foundation for human-to-human code review.

Production Engineering Across Platforms

Komitto: Challenge Management Maturity

With 31 commits this week, Komitto continued its steady progression towards a robust challenge management platform. The focus shifted from raw feature development to user experience refinement:

Challenge stats aggregation for better analytics
Profile editing with avatar upload capabilities
Modern card-based design patterns throughout the interface
React Query integration for improved performance

The commit breakdown (14 new features, 15 improvements, 3 bug fixes) shows a project transitioning from “building” to “polishing”—a healthy evolution that often separates successful products from feature-rich but unrefined ones.

Breedr Mobile: The Art of Incremental Excellence

Breedr Mobile saw 50 commits focused on interface consistency and tag management enhancements. The work included:

Refactoring tag application logic to support more flexible data structures
Adding progress indicators for draft sections
Improving layout consistency across tablet and mobile views
Enhancing validation logic for livestock management workflows

This represents the unglamorous but essential work of production mobile development. Each commit individually might seem minor, but collectively they represent the difference between software that works and software that feels crafted.

Electron Bluetooth Exploration

Perhaps the most technically interesting work was exploring Bluetooth capabilities in Electron for a potential desktop application. With 16 commits over just a few days, this proof-of-concept investigation covered:

Real-time BLE device scanning and connection management
Data streaming with comprehensive error handling
Connection reliability improvements for livestock tracking hardware

The project reinforced that Electron has matured significantly for hardware interaction scenarios. The combination of web technologies with native system access creates compelling possibilities for desktop applications that need to interface with Bluetooth devices.

The Philosophy of Tool Building

One pattern that emerged this week is the relationship between problem-solving and tool creation. Whether it’s the AI code review system, the git summary scripts, or the Repomix enhancements, each tool emerged from a specific frustration with existing workflows.

But there’s a balance to strike. As engineers, we can sometimes default to building tools when we should be solving the underlying problem differently. The key question isn’t “Can I build a tool for this?” but rather “Will this tool genuinely improve outcomes, or am I just procrastinating on the harder work?”

The AI code review tool passes this test because it creates better feedback loops. The git summary scripts pass because they reduce the cognitive load of retrospection. The Repomix enhancement passes because it makes code analysis more precise and less tedious.

Engineering Management Reflections

From a leadership perspective, this week highlighted the importance of sustainable engineering practices. When individual contributors are struggling with cognitive load—whether from poor sleep, stress, or simply the complexity of modern development—the systems and tools we’ve established become critical safety nets.

The teams building the most reliable software aren’t necessarily the ones with the best individual engineers; they’re the ones with the best collective systems. Code review processes, automated testing, deployment pipelines, and knowledge sharing practices all serve as cognitive scaffolding for the entire team.

Looking Forward

As we move into another week, I’m carrying forward a few key insights:

Simplicity as a Strategic Choice: The SLC philosophy isn’t just about product development—it applies to tool building, process design, and architecture decisions. Simple, complete solutions often outperform complex, comprehensive ones.

Automation for Cognitive Health: Tools that reduce mental overhead aren’t just productivity enhancers—they’re essential for sustainable engineering practice, especially in complex domains like mobile development with AI integration.

The Value of Cross-Platform Exploration: Working across React Native, Electron, and web technologies this week reinforced the benefits of maintaining broad technical familiarity rather than deep specialisation in a single platform.

Next week will likely see continued iteration on these themes, plus the inevitable new challenges that come with engineering leadership. The goal isn’t to eliminate complexity—it’s to manage it more thoughtfully.

Remember: the best engineering solutions are often the ones that feel inevitable in retrospect, not the ones that showcase technical sophistication. This week reinforced that sometimes the most productive thing you can do is step back and ask whether you’re solving the right problem in the right way.