For the past month, I’ve been running an experiment: could I build multiple full-stack applications and supporting tools—without writing any code myself? Not a single line. Instead, I relied on natural language instructions, documented protocols, and a conversational workflow with my AI assistant. The result? Two apps, two MCP servers, and a mountain of lessons learned.
This post is a candid reflection on the highs, lows, frustrations, and what this approach means for lapsed developers like myself, non-developers, and the future of technical roles.
The Setup: Zero Code, All Conversation
Let’s be clear: I did not write any code. Every feature, fix, and protocol was implemented by guiding the AI through documentation and natural language. My role was to articulate requirements, document patterns, and enforce protocols. The AI handled the rest—sometimes brilliantly, sometimes not.
Highs: What Worked Well
1. Documentation as the Real Programming Language
The instructions file became the backbone of the process. Every rule, pattern, and workaround I documented was picked up and followed by the AI. Once a solution was documented, it was never violated again. This turned documentation into executable knowledge, making the AI a compiler for my specifications.
2. Fixes That Stuck
When things broke—especially around authentication and platform compatibility—the AI was able to apply documented patterns from previous fixes. For example, switching to non-interactive authentication for background services became a reusable solution, saving hours of troubleshooting.
3. Protocols Over Trial-and-Error
After several failed attempts at debugging layout issues, I established a multi-phase investigation protocol for CSS problems. This forced a thorough analysis before any changes were made, eliminating the usual cycle of incremental, ineffective fixes. Real-world feedback helped refine these protocols, making them robust and repeatable.
4. Building Tools for the AI
When I found myself repeatedly teaching the AI the same investigation process, I codified it into supporting tools. These tools made the AI smarter and more effective, shifting my approach from “using AI to build apps” to “building tools that make AI better at building apps.”
5. Cost-Conscious Automation
The AI consistently suggested cost-saving measures—production-only automation, caching, and environment-aware operations—without being prompted. This operational awareness was invaluable, especially for API-heavy projects.
Lows & Frustrations: What Didn’t Work
1. Knowing When to Stop
Some attempts at building supporting tools failed spectacularly, despite multiple tries. SDK migration issues, runtime validation errors, and destructive automation led to wasted time and mounting frustration. The lesson: after 3–4 failed attempts, it’s time to stop, reassess, and consider alternatives. Sometimes, “ship what works” is better than chasing theoretical improvements.
2. Documentation Discipline
While documentation was recognised as critical, it wasn’t always enforced. Gaps in session notes meant some lessons were only captured in reflections, not systematically documented. Accountability and discipline are as important for AI as for humans.
3. Filling in the Blanks
Early on, the AI would invent plausible-sounding details when information was missing. Explicitly prohibiting this in documentation led to better behaviour—asking clarifying questions instead of fabricating data.
What Does This Mean for Lapsed Developers and Non-Developers?
The New Role of Domain Knowledge
Here’s the reality: while I didn’t write any code, I did rely heavily on domain knowledge—architecture, protocols, authentication patterns, and debugging strategies. The AI was brilliant at following documented patterns and executing instructions, but it needed clear, explicit guidance. Without a foundation in how systems work, it’s unlikely someone with zero technical background could have achieved the same results.
Empowering Non-Developers (and Lapsed Developers)
This approach radically lowers the barrier to entry for building software. If you can articulate requirements, document processes, and understand the basics of how systems fit together, you can build surprisingly complex solutions. For lapsed developers, it’s a way to leverage experience without getting bogged down in syntax or frameworks. For non-developers, it opens the door to technical creation—provided they’re willing to learn the language of architecture and process.
The Impact on All Roles
- Developers: The focus shifts from writing code to designing systems, documenting patterns, and guiding AI partners. Deep technical skills remain valuable, but the bottleneck moves to clarity of thought and communication.
- Architects & Analysts: Your ability to define, document, and enforce protocols becomes the key driver of success. The AI can execute, but it needs a blueprint.
- Project Managers & Product Owners: You can now participate more directly in the build process, provided you can translate requirements into actionable documentation.
- Non-Technical Roles: With the right domain knowledge and documentation discipline, you can contribute to building and maintaining systems in ways that were previously out of reach.
Domain Knowledge: The Secret Ingredient
The experiment proved that domain knowledge is the real differentiator. The AI can follow instructions, apply patterns, and even suggest improvements—but only within the boundaries of what’s documented and understood. The more explicit and thorough the documentation, the better the results. Conversely, gaps in understanding or documentation lead to confusion, errors, and wasted effort.
Final Thoughts
The biggest surprise? The profound difference between building WITH AI and building FOR AI. Application development succeeded quickly; tool development required deeper understanding and was more failure-prone. The biggest win was fixing a broken system in minutes by applying documented patterns. The biggest failure was spending days on a theoretical improvement that never worked, while a working solution sat unused.
Bottom line: Vibe coding with AI isn’t about letting the machine do the work. It’s about having a conversation partner that challenges your assumptions, remembers documented patterns, and forces explicit requirements. The code is often better, the process can be faster, and documentation is mandatory. But knowing when to stop and ship what works is still human judgment.
And sometimes, the AI breaks things. And sometimes, you fix them in one session by applying patterns learned from other projects. That’s the vibe.
What’s New from Microsoft
Microsoft announces Confidential AI Business Professional Certification: Equipping professionals to lead secure enterprise AI adoption strategies. – https://techcommunity.microsoft.com/t5/ai-machine-learning-blog/introducing-microsoft-confidential-ai-business-professional/ba-p/4123456)
Durable Task Extension for Microsoft Agent Framework Released: Enabling resilient automation for complex workloads at scale – https://learn.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-overview
Entra ID Introduces Passkey Support: Strengthening passwordless authentication across identity platforms – https://techcommunity.microsoft.com/t5/microsoft-entra-blog/passkeys-in-microsoft-entra-id-general-availability-now-live/ba-p/4109780)
Intune Endpoint Health Check Updates: Enhanced reporting brings better device compliance visibility for IT admins – https://techcommunity.microsoft.com/t5/intune-customer-success/bg-p/IntuneCustomerSuccess
Azure Unveils Next-gen Data Center Architectures: Infrastructure optimized for massive-scale AI workloads – https://azure.microsoft.com/en-us/blog/new-data-center-design-for-ai-superfactory-workloads/
😁No ignite news this week, still digesting and will do something next week I suspect
This Week on the Podcast
Microsoft’s AI Superfactory & Security Stories That Matter
On this episode of Cloudy with a Chance of Insights, Richard Hogan joins David Rowley and Cyrus Walker to unpack some of Microsoft Cloud’s most impactful updates:
🎧 [Listen now on YouTube](https://youtu.be/GWQ)
Thanks for reading! If you found these insights valuable—or have your own stories about building with (not just for) AI—I’d love to hear from you in the comments below.
#AI #Copilot #DevTools #Microsoft #Productivity #CloudComputing #Newsletter
The Microsoft Cloud Blog 