Deterministic things are something it’s easy to have a bounded understanding of: they’re reliable, repeatable, and have obvious testable outcomes derived through a defined workflow. Input : Output. Action : Audit. Everything else is just details. As someone who has been more of a trenchman in this biz, I think like an operator or an engineer, less so as a ‘creator’ in the traditional sense. That means I’m moved by structure, reliability, and uptime, and less so the hype beast creator cycles and the screaming elations of the day. I’m not interested in the gong sounding beyond the novelty of the first time it happens. Despite the outcomes I could see people creating, I couldn’t help but wonder:

• What are the gaps? What hasn’t been captured?
• AGI, etc. More on this nonsense later
• What is the ‘vibe coding’ experience really like? What are the real outcomes?

The workplace tour of duty

For a while I successfully ignored those thoughts and used AI tool assist minimally through products like Windsurf/Copilot in a non-agentic fashion, as work prescribed I do. Those tools are helpful, but the chat bot IDE integration never felt like a good fit. Keeping it functioning amidst the shifting sea of network and security changes in the workplace made configuring and troubleshooting the chat bot half of what I did. A scenario I lived through: Visual Studio Code’s development team didn’t create any controls for that new agent feature before they rolled it out to the universe. The one the CyberSecurity team really hates. Sweet. Cue the scrambling of remediation efforts.

Despite the problems, I did see the benefits in direct terms, but slowly: LLM implementations are extremely good at navigating API structures and, more importantly, are experts at RTFM. That last one is the most critical point. Once I figured out that the quality of the inputs made such a huge difference on short-term outcomes, that made things click for the first time. Microsoft’s Graph API, a well-documented API management layer used to interact with the vast aggregation of Azure services and offerings, was something it was well suited to building code against. With quality input data, even the lesser models of the time could handle things like creating elaborate Powershell workflows. I could sort of get the hype, but I felt largely disconnected by the sheer fullsend of it all. At that point I still saw it as the better search option because modern search engines are dog vomit. And the best coding buddy I’d ever had (speaking as a non-dev).

Claude

There were hardships, but the tooling had an allure that was enough for me to begin taking it seriously. I moved beyond my initial stubbornness in my usage of AI for personal projects and adopted the Anthropic tools; Claude CLI felt like a natural fit for my style of use. Regardless of the endpoint I’d always find myself using the terminal, which is likely a good way to clock my age without carbon dating. Some things you can’t unteach, I guess. Claude Code shifted my perspective on both the possibilities and the risks.

At first I was very diligent about guided mode with permissions. For the uninitiated, Claude Code by default will operate in an inherently non-permissive mode, structurally orienting its allowed actions and tools via project directories that act as terminal working directories or a generalized ‘user’ space for Claude configurations within a .claude directory. I’d sit at attention, largely hitting ‘Yes,’ rarely hitting ‘No,’ and sometimes appending to clarify. On paper this is a working methodology, but in practice mindnumbing: tasks that Claude performs have variable execution times and numbers of steps, which conceptually recurses to subtasks as well. This means hitting the Yes/No/But option is draining despite being a job suited for George Jetson. Humans are meatbags, after all, and this operator is no exception. Why hit yes when I can just ride the vibe?

Future OG Vibe Coder

George Jetson is something of a pre-post-futurist cautionary tale. To date, I’ve made a number of personal projects in Github, most of them private. The amount of commits I have is orders of magnitude greater than anything I had bothered committing before, on any repo, on any identity, within any context. A tremendous multiplication of material effort, code, and sheer provable output. Yet I haven’t made any of the significant ones public, so where’s the real result? It turns out that real software development is difficult, and doing it right requires actual knowledge. Prompt fatigue inevitably led me to finding what the kids call ‘YOLO’ mode, engaged with a --dangerously-skip-permissions flag. The devil’s temptation.

What the vibe coders don’t tell you, or in some situations don’t understand themselves, is that none of the LLM models will do anything beyond what you tell them to do. Everything else is bounded by the arbitrary guard rails the models use. George hits the button, and gaps are filled largely by arbitrary information that works in the most technical sense, but the choice of ‘best fit’ is suspect regardless of the level of reasoning involved. Guidance in choosing options and directing the scope is still a real human requirement, and fatigue will lead users to making suboptimal decisions just to ‘get it done.’ I saw it in myself, even within personal projects. George was getting tired doing it this way, because the structure and methodology weren’t there to ensure a quality result despite the sheer capability. Good news for the rest of us, but bad news for the 2026 post-modern Jetson family and perhaps the greater Spacely Space Sprocket megacorporations that speak otherwise. Skilled labor is still necessary from what I can tell.

Questionable technology choices let me dust off memes derived from the fossil record

It’s not me, it’s them

My learning of the tool landscape and technology seemed to have a different trajectory than my fellows. It’s fast, but where’s the governance? It executes, but where’s the stability? Where’s the rigor? The accurate framing that actually suits the purpose, driven by experts (read: wisdom)? Successful outcomes seemed inherently biased and shaped by the training data, so basing something on a popular option would increase the likelihood of ‘success’ in the most relative sense. Like the station on the radio with the strongest signal always playing Taylor Swift. You’d see that sort of pattern directly in the tool choices: npm packages began to feel like a self-fulfilling prophecy despite the use case, and all roads lead to typescript. I was seeing a lot of things that I didn’t like, so I committed to taking a different approach. Something more methodical.

Two things came of this thinking in an attempt to figure it out: code-to-docs and ketchup. Code-to-docs isn’t very remarkable; it’s a code to docs facilitator Skill for Claude in a sea of them, but it works for my flow better. I like Obsidian for notes and find markdown easy to work with, so having a skill to document (and continually update the documentation of) codebases in a human readable way made sense to me, particularly for review and education. I’m not a developer, so I don’t have an innate understanding of what the agent creates in the vibe coding context, and I’ve yet to develop a sense of comfort in executing that way, which led me to Ketchup as an extension of the same idea.

Ketchup was a little more ambitious in scope. When I came to understand the value of quality inputs I also began to understand the value of RAG databases and tooling like it in the language model space, and I happily stumbled upon Context7, an Upshift product. Context7 is an api service that provides llm-optimized and formatted knowledge of manuals and technical data, so it excels at providing instructional inputs. As a nascent dev type, I really wanted a way to close the gap on various knowledge topics, but with a variable perspective. Something like ‘ReactJS, but for an AS400 technician 20 years out of date.’ A hyperbolic example, but you likely get the idea. I wanted something that could provide knowledge on topic but framed for a perspective, idea, or occupation. Ketchup ultimately provides this with a slash command and a minimum of parameter data supplied.

At this point, I was starting to feel it, but I couldn’t shake my doubts either. Creating a solid knowledge framework engine derived from Claude Code, MCP tooling, and markdown files felt great for learning, but definitive product output was still something tenuous and uncomfortable to deliver.

TBC