Vibe Coder
How I Spent Thousands of Dollars, Countless Hours, Almost Got Things Working, and Learned More Than I Expected
I built a system that could scan governance forums, analyze proposals, coordinate discussions in Discord, and present the results on a public website.
Well, almost.
This is the reality of vibe coding - you can spend countless hours and thousands of dollars building things that almost work. But here's what I've learned: that "almost" teaches you more about software development than any bootcamp ever could.
How I Got Here (The Short Version)
I got my first computer at six years old (not common for someone my age - remember I’m ancient). I spent my formative years deep in technology, then around 14 discovered the guitar. The allure of rock and roll was much more appealing than learning to code, leading me into two decades as an operator.
My biggest regret is that I didn't follow my technology roots and pursue software development. As I grew older the barriers to entry always seemed insurmountable. I've written more about that journey from creator to operator, but economic necessity kept me away from focusing on learning to code, until recently.
When ChatGPT emerged, I realized I could finally bridge that gap. I had moderate conceptual understanding of how software development and complex systems worked, but lacked the granular, "getting my hands-dirty" details. Here was my coding partner that wouldn't judge me for asking basic questions.
When I stumbled across Optimism's AI Delegate RFP, it felt like the perfect opportunity to put this theory to the test.
The AI Parliament: A Case Study in "Almost"
When I saw Optimism's mission request for governance infrastructure improvements - specifically seeking AI agents that could enhance delegate participation and reduce information asymmetry in their governance process - I got inspired. As a delegate I can sympathize with the reality of drowning in proposals without enough bandwidth (or expertise) for thorough analysis on everything.
What I envisioned: A system called the AI Parliament with specialized agents that could scan governance forums, analyze proposals from multiple perspectives, discuss findings in Discord, and present insights through a web interface.
What I got working: The system could scan forums and surface posts. A couple of the “agents” could analyze proposals in Discord and generate summaries. I had a frontend displaying results.
Where "almost" kicked in: Getting these systems to work together reliably as true agents. What I built were essentially chatbots that could talk to each other and perform specific tasks, but they weren't really "agents" in the true sense - autonomous systems that can plan, execute complex workflows, and adapt based on results.
This project taught me an important distinction: most of what people call "AI agents" today are really just glorified chatbots (yes, this includes most of the tokens from the recent AI Agent Craze). They can follow scripts, respond to prompts, and even chain a few actions together, but they're not truly autonomous.
Real agent orchestration - systems that can independently plan, execute, monitor, and adapt their behavior - is still beyond what most of us that are vibe coding can achieve.
Through all this trial and error, I've become accidentally expert in the current vibe coding landscape. This brings me to the tools of the trade…
The Tools That Got Me This Far
Each time something broke or didn't integrate properly, I'd try a different approach, a new platform, another AI agent. Thought it might be useful to share what I've used and what I learned:
General Purpose LLMs
These are your primary thinking partners - the AI you chat with to solve problems, debug issues, and figure out what is next. They're where most vibe coding starts, whether you're prototyping an idea or trying to understand why something isn't working. The key differences between them come down to interface features, context handling, and how well they maintain momentum during coding sessions.
Claude - My primary partner. What sets it apart is its amazing ability to understand and reason and provide guidance. The MCP functionality through Claude Desktop lets me connect to repositories and data sources, which became essential for complex projects like the Parliament system. It’s biggest downfall? Context window (though they did recently expand with the release of Sonnet 4).
ChatGPT - I use o3 for complex questions and 4o for quick answers. Advanced voice mode on walks is great for thinking through architecture problems along with peer review of things from Claude and the agents I mention below.
Gemini - Really fast with a large context window, excellent for PRDs and technical specs. Google's been pushing hard in the vibe coding space and it shows - their web development capabilities are top-notch. Not as polished as Claude for iterative development, but rapid improvements from just a few months ago with the initial release.
IDEs
Think of these as your coding workbench - they combine a traditional code editor with AI superpowers built in. These tools understand your entire project context and can make changes across multiple files intelligently. The difference between a good AI powered IDE and a basic one is whether it feels like you're working with a junior developer who gets it, or constantly explaining yourself to someone who doesn't.
Cursor - The de facto vibe coder standard (and for good reason). The agent functionality is advanced and works really well for rapid prototyping. What makes it special is the unified Agent mode that combines chat and compose into one intelligent interface. It understands your entire project context without you manually selecting files.
Windsurf - Windsurf's Cascade feature provides true multi-step AI agent functionality with deep codebase understanding. It's watching everything - your edits, terminal commands, even clipboard activity - to infer what you're trying to build.
Zed - Approachable IDE that works out of the box. Great beginner option if you want something that feels familiar but has AI built in. The unique thing about Zed is that all AI interactions are visible as plain text, so you can see and edit the reasoning process.
VSCode - The OG that legitimized AI-powered coding with GitHub Copilot integration and massive extension ecosystem. While it's solid and battle-tested. For vibe coding, I prefer the more nimble alternatives, but VSCode remains the safe choice if you want maximum compatibility and enterprise support.
Agents
Agents go beyond just answering questions - they can actually execute tasks, run commands, and modify your codebase autonomously. These are your digital interns that can work independently once you give them direction. The safety and control mechanisms vary wildly between agents, which matters a lot when you're trusting them to modify your actual project files.
Cline - My secret weapon for complex debugging with excellent context windows. What makes Cline special for vibe coding is the human-in-the-loop approach - it shows you exactly what it wants to do before doing it. This is perfect when you're learning or working on something you don't fully understand.
Claude Code - Command-line agentic tool included with Claude Max subscription. It's basically Claude but with the ability to read, write, and execute files directly. Great for when you want to stay in the terminal but need AI assistance.
GitHub Copilot - Good for GitHub-related tasks. The asynchronous agent shows promise - you can assign issues to it like you would a team member. Recent multi-model support means you can choose between different models depending on your preferences and needs.
Manus - This operates like a chat interface but spins up virtual machines and coordinates multiple agents behind the scenes. Can deliver end-to-end projects but often needs iteration. The difference is that Manus feels more like working with a digital intern than a coding assistant - it can handle entire business processes, not just code generation.
Devin - Like Manus, Devin comes with its own browser, code editor, and terminal in a sandboxed environment for end-to-end engineering tasks. Can learn unfamiliar technologies, build and deploy apps, and work directly within Slack workflows.
CodeRabbit - Catches bugs and issues in your code through conversational code reviews directly in GitHub comments. Runs code through dozens of industry-standard linters and security analyzers, learns your team's preferences over time.
No-Code Platforms
These platforms let you build real applications without writing traditional code at all - you describe what you want in plain English and they handle all the technical implementation. They're great for testing ideas quickly or for people who want to build something functional without learning programming fundamentals. The trade-off is usually flexibility versus speed - you can build fast, but you're limited to what the platform can generate.
Lovable - My preferred platform with intuitive interface and good remix functionality for sharing/forking projects. What makes Lovable special is the "99% who don't code" philosophy - they've optimized everything for complete beginners. The chat-first interface combined with visual editing means you can build real applications without understanding the underlying tech.
Replit - Browser-based coding environment, great for mobile development and quick prototyping. The checkpoint pricing model is clever - you only pay for completed work. Better for learning programming concepts than pure vibe coding, but the educational value is real.
Bolt.new - Bolt gives AI models control over the entire development environment - filesystem, node server, package manager, terminal, and browser. You describe what you want and get a real, working full-stack application running in the browser within minutes.
v0 by Vercel - v0 generates beautiful React UIs from text prompts. You describe your UI vision and it generates multiple code variations for each element. Can handle 3D graphics, convert images to code, and exports cleanly into projects. Perfect for eliminating the design bottleneck.
Infrastructure and Tools
In traditional development, setting up infrastructure can take days or weeks and requires deep technical knowledge. For vibe coding, you want infrastructure that "just works" so you can focus on building your actual idea rather than fighting with servers and databases.
Supabase - Backend-as-a-service for databases and authentication. What makes Supabase great for vibe coding is the one-click integration with platforms like Lovable and Bolt. The SQL-first approach with instant API generation eliminates all backend complexity. The natural language to SQL conversion means you can build database functionality without understanding databases.
Railway - Cloud infrastructure platform that excels at removing deployment friction. One-click GitHub integration, zero configuration requirements, and visual infrastructure dashboards that make sense to non-technical users.
Notion - Surprisingly useful for simple databases with easy integration. Familiar and intuitive.
For the Parliament project specifically, I relied heavily on Manus for the initial build out, Claude for ad hoc questions and assistance from Windsurf with Cline for iteration.
The Context Window Problem
Here's the biggest takeaway: context management will make or break your project.
When I started the Parliament project, I was doing what most people do - opening Cursor, throwing vague prompts like "build me an AI governance system," and hoping for the best. The Parliament Alerter frontend looked great in Manus. The Discord bots worked when I ported the codebase and started working on it locally.
But when I tried to connect them? They had no context of what others had built and why they designed it the way they did.
Cline would suggest changes that broke the Manus-built frontend. Claude would recommend changes that didn't align with how Cline built certain components. I was constantly losing track of what worked where, and getting caught in endless loops where AIs were contradicting each other's solutions (and spending a lot of money in the process).
What I learned (and what I wish I'd known):
After failing repeatedly, I discovered that successful vibe coding isn't about being a "vibe coder" - you're actually acting as a product owner. @vasumanmoza shared a system that would have saved me a lot of time:
Architecture Planning First: Use ChatGPT (4o model, Gemini works well for this too) to define your entire project architecture in Markdown - file structure, component purposes, state management, service connections.
Granular Task Breakdown: Get that same LLM to create a step-by-step MVP plan with small, testable tasks that have clear start and end points.
Structured Execution: In Cursor/Windsurf, have the AI read both documents, then complete ONE task at a time, stopping after each for testing and committing working code before moving on.
The key insight: you need a roadmap to keep AI-assisted coding on track, not just throwing prompts and hoping.
My lessons learned:
Build specs, not instructions - Describe what needs to be accomplished, let the tool decide implementation
One AI per major component - Don't have multiple AIs working on the same codebase simultaneously
Document your architecture - Create detailed project memory that any AI can reference
What "Almost Working" Teaches You
The most important thing this journey taught me: a deep appreciation for real developers and why they're still essential for building complex systems.
Six months ago, I understood many of these components conceptually but couldn't implement anything. Today, I can build functional prototypes, set up basic integrations, and create working demonstrations. But when I hit the complexity wall - like making six different “agents” work together - I realized how much I still don't know.
Real developers understand things I'm just starting to glimpse: how to design systems that scale, how to handle failures gracefully, how to write code that other people can maintain, how to architect solutions that won't break when you add new features. The distance between "works on my machine" and "works reliably in production" is enormous.
Skills you gain from "almost working" projects:
Systems thinking - Understanding how different components need to communicate
Debugging methodology - Learning to isolate problems and test systematically
Tool selection - Knowing which AI is best for which type of problem
Realistic scope assessment - Understanding what's actually achievable vs. what sounds good in theory
Appreciation for real engineering - Recognizing the gap between prototypes and production systems
These skills represent something deeper than just technical learning - they're part of adapting to a shift in how we build software. What I experienced through vibe coding isn't just a new way to write code; it's a glimpse into the future of human-computer interaction.
The Evolution of How We Interact with Computers
As Andrej Karpathy recently noted, we're witnessing the emergence of "Software 3.0" - where English prompts replace traditional coding. This isn't just a minor shift; it's the natural evolution from his "Software 2.0" concept where neural networks began eating traditional software.
We've moved from learning computer languages to talking to computers.
This shift is why someone like me - who spent two decades as an operator, avoiding the technical deep end - can suddenly build functional prototypes. The Parliament project would have been impossible for me to even attempt just a year ago. Not because the underlying technology was different, but because the interface between human intent and computer execution has fundamentally changed.
Think about the progression: Software 1.0 required you to learn programming languages and frameworks. Software 2.0 let neural networks handle some of the complexity, but you still needed to understand model training and data pipelines. Software 3.0 lets you describe what you want and watch it materialize.
We're still in the early stages of this transition. Tools like Claude and Cursor feel magical when they work, but they're not yet sophisticated enough to handle true system-level thinking. The context window problem I hit is a challenge in translating human architectural vision into code that actually integrates properly.
The tools are improving fast enough that my Parliament project might actually work if I tried building it today with better architecture planning and the newer agent capabilities. That's the trajectory we're on - the gap between "I have an idea" and "I have a working prototype" shrinks every few months.
For operators like me, this represents the biggest shift in our relationship with technology since the personal computer. We're moving from being consumers of software to being creators of it, even without traditional programming skills. The question isn't whether this will continue - it's how fast we can adapt to it.
What’s Next?
Six months ago, I was an operator who understood systems conceptually but couldn't build them. Today, I'm working on various ideas and experiments including some updates to my Crypto Grant Wire that you’ll see (if I can get it working). Better architecture planning, realistic scope, and the hard-earned knowledge that you need to be a product owner, not just a prompter.
Traditional software development erected massive barriers: bootcamps, computer science degrees, years learning syntax and frameworks. Vibe coding eliminates those barriers, but creates new challenges around AI management and system design.
The most important lesson for other operators? Just start, but start smart. Don't make my mistake of throwing vague prompts at Cursor and hoping for magic. The tools are powerful enough now that you can build real things, but you need enough development intuition to guide them when they get confused. Without that, you'll get lost in endless loops of conflicting AI suggestions like I did.
We're living through the biggest shift in our relationship with technology since the personal computer. The barriers that kept operators out of building software for decades are dissolving. The question isn't whether this will continue - it's how fast we can adapt to it.
The juice is definitely worth the squeeze. Even when things almost work.
Peace,
Sov