My Foray Into AI Coding
Since this past April, I've been experimenting with Claude Code. Shockingly, what started as a small, personal app testing the capabilities of AI turned into a fully functional app I dubbed "Nexus". I published it, and you can check it out here.
This essay is a snapshot in time — documenting my experience. I've been impressed and humbled at the frontier model capabilities. It's shocking what's currently possible, and I (like everyone else) am struggling with the implications. If they're not already, I suspect these sorts of stories to be commonplace in the next few years.
I actually started writing an earlier version of this essay about two months ago. Normally, I write when I feel motivated — slowly and deliberately, and when I get to something that feels like a complete thought, I publish.
But since I started writing:
- Anthropic developed a new class of model too dangerous to release to the public — and launched a corresponding initiative to try to prepare cyber defenders.
- That model escaped the sandbox designed to contain it (researchers did instruct it to do so).
- OpenAI announced its models also escaped containment and breached Hugging Face (a sorta-GitHub-for-AI company).
It's taken me so long to finish that it all feels outdated. So for now, I'm writing something describing my experience, which feels more important than waiting for the dust to settle.
What I Built
Although this isn't intended to be the meat of this essay, it's worth briefly describing what I built.
I've always been a productivity nerd. Like most nerds, that means I've spent plenty of time with productivity apps like OmniFocus, Todoist, and the Swiss Army knife of productivity — Obsidian. I've amassed a huge collection of notes tracking books, workouts, essays, goals, maintenance records — you name it, I probably have an entry for it.
My Obsidian notes database.
The issue with Obsidian is that it only tracks and displays ~85% of what I want (better than most other tools!), and I'm left striving for the remaining fifteen percent through community plugins and feature updates released through the main app1.
When I realized AI could legitimately produce working code with direction from a non-technical user, I couldn't help but try and build myself a to-do / productivity app that fit my exact needs. Rather than pay for a subscription to a platform that doesn't quite have everything, for roughly the same subscription price, I could have an LLM build it for me!
I started with a module-based design so that, as I thought of other additions, they would fit into the app nicely. To date, I'm up to ~18. You can read more about all it does on the landing page.
Now — to the AI coding bit.
Setup
I used Anthropic's Claude to build my app because at the time, Claude Code paired with its Sonnet-class model was considered the best coding software out there (I'll refer to the LLM throughout the rest of this essay as "Claude", but you can substitute any similarly capable model).
The most technically complex bit was understanding a little bit about how to host a website on the internet (which I have a basic understanding of). At its most basic level:
- You need a computer somewhere to process web requests.
- You need a database, where all the text in your app lives.
- You need file storage, where all your bulky big non-text data lives.
But the best part about working with Claude was that it gave me all the instructions and recommendations of which services to use — including which services offered "free-tiers" which would likely cover most of my usage. I chose Cloudflare Pages to serve traffic, and Supabase as my database and file storage. To date, I haven't paid a single dollar for any actual hosting of the service!
Interestingly, you don't actually need to know much about this stuff if you want to build. If you're okay spending a little money, there are apps like Vercel that handle all this for you, and let you just prompt. There's also Base44, and even more interestingly, Google is building this right into search, with something called "Generative UI".
Pretty soon, anyone who Googles will be able to build custom apps.
Coding With Claude
I heard someone say once that coding with Claude is like having a really competent coding friend that will do exactly what you say, nothing more, nothing less.
For that reason, people would get mixed results when using Claude. If you just said:
Make me a to-do app, I want it to have dates when things are due, reminders, and a nice interface.
It would make you something, but it wouldn't be great. Instead, the unlock for me was realizing that a separate chat with Claude could help me flesh out my ideas, which I could then feed back into the version of Claude that was coding for me.
I would often spend 20-30 minutes in a chat session starting with the same sentence above, prompting Claude to interview me until it was comfortable writing a technical specification document detailing exactly what I wanted to build. Once it produced that, Claude Code followed it — to the letter.
Later on, Anthropic realized this, and has largely integrated what it calls "Plan Mode", where it automatically performs this action, writes plans for itself based on user prompts, then carries out those plans. It feels a little snake-eating-itself, but it's effective. 🐍
Security
Security still kinda frightens me. Sure, I can get Claude to generate some code for me, but is it secure? Two things immediately come to mind:
- Slopsquatting — registering package names that AI tends to hallucinate on existing public registries, then filling them with malicious code.
- AI Poisoning — In 2023 some research came out describing AI Poisoning: publishing malicious data with the intent to have models trained on it, ultimately producing insecure code.
Slopsquatting
In 2025 — according to Trend Micro:
"Slopsquatting is a modern supply-chain threat in AI-powered workflows."
And...
"Advanced coding agents and workflows such as Claude Code CLI, OpenAI Codex CLI, and Cursor AI with MCP-backed validation help reduce—but not eliminate—the risk of phantom dependencies, as even real-time validation cannot catch every edge case."
For a while, package maintainers tried to deal with this problem, but through automation and AI tools of their own, attackers have a significant advantage.
But putting safeguards in your IDE directly can help.
- Release cooldowns give defenders time for security review before your agent downloads a package.
- Sandboxing provides a bit more isolation and protection for the rest of your filesystem outside of the agent's working directory.
- Disabling Install Scripts sets a good default safeguard, forcing you to opt-in before code execution is initiated during an install (something that NPM is making a default in v12).
AI Poisoning
On the AI poisoning front, it feels suspiciously...quiet? Certainly, it seems like the models are getting better and better. Despite poisoning-in-protest, frontier model companies filter and sanitize datasets long before they become part of the model. If it were an issue, I imagine a lot of folks would be making noise about it. But given the myriad development cycles, code verification, and other internal review functions — a model consistently writing insecure code seems hard to attribute. It's something that's hard to measure, and no frontier labs currently publish their pretraining data integrity pipeline / data provenance.
The logical safeguard to this issue (so far) at the enterprise level seems to be: model output should be untrusted by default. Generated code passes through automated scanning, behavioral evaluation, and (snake eating itself here again) AI security analysis. On that last point, it doesn't really seem like there's been mass-adoption of robust internal AI security analysis, even though the tools are available (maybe companies just aren't talking much about it right now).
Regardless — at an individual (hobbyist) developer level, you can achieve similar results using the most advanced models (like Fable 5) for automated scanning. A full codebase security code review from a capable model feels at least as thorough as (and probably more thorough than) anything I could reasonably pay a developer to do. Plus, these machines never get tired, so it's easy to create clever setups like a /loop command inside a CLI to have Claude monitor, review, and flag CVEs continuously (which I do).
My current calculus is this: using the latest generation models, industry-best practices (like database row-level security and encryption-at-rest), and regular AI security audits — probably leaves you with a fairly secure setup.
Technical Complexity And "Not" Building Something
There are some areas where, due to their technical complexity and importance, coding them from scratch feels a bit like reinventing the wheel. Primarily, for me this was user authentication.
- It's an area that I don't have a lot of experience in.
- Having an AI code the entire thing is possible, but perhaps not prudent.
- Handling passwords, encryption, password resets, and all the other small quality-of-life user stuff would take a lot of energy (and tokens), and result largely in me building functionality that already exists out there.
- Supabase offers user authentication for "free" by running the DB there.
I didn't vibe-code any user auth for those reasons.
Velocity
An honestly confusing point to me is — why aren't companies moving faster? Given how quickly AI can iterate, it seems like the only reasonable answer is legacy code, stability, and poor internal processes.
I think established companies with slow existing processes are in for a shock in the coming years. Organizational transformation at these sorts of places is slow. Venture-backed AI-native startups with their new AI-agility superpowers will grow up lean, outmaneuver their competition, and punch above their weight class.
AI Works for You (And Me)
What's neat about designing your own app is that you can have any feature you want that works any way you want. During the Alpha stage of this app, as I've had my friends and family testing different features, every module update was a few text prompts. In a few minutes not only did I have a working prototype, I had the completed feature. That's cool.
It begs the question: when anyone can build anything, how do you distinguish the good from the bad? It's sorta an everything everywhere all at once situation.
My personal thought is it comes down to taste. With AI coding, that means steering.
Nexus is opinionated in the way it works because I'm opinionated about the UI and how it's designed. I routinely find myself spending tokens discussing and describing design philosophy, more than any sort of technical implementation requirements. Soon, I think we all will work this way.
Of which there are many — the Obsidian plugin community is tremendously active so this actually goes a long way.↩