Week 3: Embracing Beginner's Mind in AI-Powered Engineering

Week three has been a fascinating exploration of contradictions: embracing beginner’s mind whilst leveraging sophisticated AI tools, questioning established patterns whilst building upon proven foundations, and maintaining engineering rigour whilst celebrating the joy of rapid prototyping. Sometimes the most productive weeks are those that challenge our fundamental assumptions about how software should be built.

The highlight of this week was discovering an article that perfectly articulated something I’ve been feeling but couldn’t quite express: “My AI Sceptic Friends Are All Nuts.” The piece cuts through the hand-wringing about AI replacing developers to focus on the practical reality of how LLMs are transforming day-to-day engineering work.

The LLM Reality Check

Two quotes from the article particularly resonated with my recent experiences:

“LLMs can write a large fraction of all the tedious code you’ll ever need to write. And most code on most projects is tedious.”

This hits at something fundamental about engineering management that we don’t often discuss openly. As technical leaders, we spend considerable time on work that isn’t intellectually stimulating—boilerplate, configuration, repetitive patterns, and the thousand small adaptations that any real codebase requires. AI tools aren’t replacing the creative problem-solving aspects of engineering; they’re eliminating the drudgery that prevents us from focusing on those aspects.

“LLM can be instructed to just figure all that shit out. Often, it will drop you precisely at that golden moment where shit almost works, and development means tweaking code and immediately seeing things work better. That dopamine hit is why I code.”

This captures something crucial about the developer experience that productivity metrics often miss. The joy of engineering isn’t in writing perfect code from scratch—it’s in that iterative dance between intention and implementation, where small adjustments yield visible improvements. AI tools amplify this by getting us to that “almost working” state faster, leaving more time for the satisfying work of refinement and optimisation.

VoidNote: When Tool Envy Becomes Creation

My ADHD brain struck again this week, as I found myself abandoning other projects to dive headfirst into building VoidNote—a cross-platform note-taking application inspired by the excellent AntiNote. The lack of a mobile companion app bothered me enough to start building my own version, designed to be cross-platform from day one.

What’s fascinating about this project isn’t just the technical implementation, but how it exemplifies the beginner’s mind approach. Rather than immediately reaching for complex architectures or established patterns, I’m approaching each decision with fresh eyes:

Week’s Progress Breakdown:

• New Features: 20 commits focused on core functionality
• Improvements & Refactoring: 15 commits enhancing user experience
• Bug Fixes: 7 commits addressing edge cases
• Total Commits: 50 across the week

The feature development included text formatting utilities, paste detection hooks, swipe-to-delete navigation, auto-save functionality, and comprehensive onboarding flows. But more importantly, each implementation decision started with the question: “What would make this feel delightful to use?”

This approach led to some unconventional choices. Rather than implementing a traditional rich text editor, I focused on intelligent paste formatting and seamless cross-device synchronisation. Instead of feature-heavy note organisation, I prioritised fast capture and frictionless retrieval. The result is software that feels more like an extension of thought than a separate tool.

Breedr: The Discipline of Iteration

Meanwhile, Breedr entered its “cool down” phase—a deliberate period between development cycles focused on learning, technical debt, and process improvement. The frontend team took time to share knowledge about AI tools and daily workflows, creating space for reflection that’s often missing in continuous delivery cycles.

Week’s Technical Focus:

• New Chute API Integration: Enhanced livestock management workflows
• UI Enhancements: Improved navigation and user feedback systems
• Layout Consistency: Better responsive design across tablet and mobile
• Code Quality: Refactoring GraphQL types and component structures

The recent work shows a project in healthy maintenance mode, with a good balance of new features, improvements, and bug fixes.

The Philosophy of AI-Assisted Development

Both projects this week benefited enormously from AI-assisted development, but in different ways that illuminate how these tools can enhance rather than replace engineering judgement.

For VoidNote (greenfield development), AI tools excelled at generating boilerplate, suggesting implementation patterns, and providing rapid prototyping capabilities. The LLM’s ability to understand context and generate working code meant less time fighting with configuration and more time refining user experience.

For Breedr (mature codebase), AI assistance proved most valuable for code review, refactoring suggestions, and documentation generation. The AI’s ability to understand complex existing codebases and suggest improvements without breaking established patterns was particularly impressive.

The key insight: AI tools adapt to different development phases and project maturity levels. The trick is recognising which type of assistance will be most valuable for the specific context you’re working in.

Technical Leadership in the AI Era

From a technical leadership perspective, this week highlighted how AI tools are reshaping team dynamics and individual contributor experiences. The frontend team’s knowledge sharing session revealed that everyone is experimenting with different AI workflows, but few have systematic approaches to maximising their effectiveness.

Emerging Patterns:

• Code Generation: Moving from “can AI write this?” to “how can AI help me explore different implementation approaches?”
• Review Processes: AI-assisted code review as a complement to human review, not a replacement
• Learning Acceleration: Using AI to quickly understand unfamiliar codebases or technologies
• Documentation: Automated generation of technical documentation from code comments and commit messages

The most successful engineers aren’t necessarily those using the most sophisticated AI tools, but those who’ve developed clear workflows for when and how to leverage AI assistance.

The Practical Philosophy

One of the most valuable realisations this week was about the relationship between philosophical approaches and practical engineering decisions. Beginner’s mind isn’t about discarding experience—it’s about holding that experience lightly enough that it doesn’t constrain fresh perception.

When building VoidNote, my React Native experience informed technical choices without dictating user experience decisions. When improving Breedr’s codebase, knowledge of established patterns guided refactoring without preventing exploration of alternative approaches.

The AI article’s perspective on professional software development resonated here: “Professional software developers are in the business of solving practical problems for people with code. We are not, in our day jobs, artisans.”

This doesn’t diminish the craft aspects of engineering, but it provides helpful perspective on when perfectionism serves users and when it serves only our own preferences.

Looking Forward

As we move into week four, I’m carrying forward several key insights:

Tool Building vs Problem Solving: The best engineering solutions often emerge from questioning whether we’re building the right thing, not just building things right.

AI as Thought Partner: LLMs are most valuable when they accelerate the exploration of ideas, not when they automate the generation of predetermined solutions.

Sustainable Innovation: The most impactful changes often come from consistent application of fresh perspectives to familiar problems, rather than dramatic architectural overhauls.

Team Learning: Creating space for knowledge sharing and experimentation is essential for teams adapting to rapidly evolving tooling and practices.

Next week promises continued iteration on both projects, plus the inevitable emergence of new challenges that will test these philosophical approaches against practical constraints. The goal isn’t to solve every problem with fresh eyes, but to maintain enough beginner’s mind that we notice when established patterns are limiting rather than helping.

Remember: the most profound engineering insights often come from asking simple questions that everyone assumes have obvious answers. This week reinforced that curiosity remains our most powerful debugging tool.