The Scenic Route to Software: Code Generation for Non-Traditional Developers

Observations from a self-taught developer building in public

I've spent the last few weeks experimenting with Cursor, and it's got me thinking about how AI is reshaping what's possible for developers like me - those of us who found our way into tech through unconventional paths. As I've been using it to build Zettelgarden, I've realized these AI coding tools are particularly powerful for people in my position: technical enough to build things, but maybe not writing code eight hours a day. They give us leverage, letting us punch above our weight class and build things that would have been much harder to tackle alone.

The Scenic Route to Tech

I was always into computers as a kid, but I studied humanities in university and ended up as an accountant (I was an auditor in a past life). The closest I got to coding was running Linux on my laptop and writing papers in Emacs and LaTeX during university. Back in 2009, that was weird, not cool.

But here's where it gets interesting: being an accountant actually launched my coding journey. When you're staring at spreadsheets all day, you start thinking "there has to be a better way." So I wrote some truly awful Python scripts to automate my work. Those terrible scripts taught me a lot about how (and how not) to build software. Eventually, this led me to a job automating finance processes, and now I work in technology management.

I've been coding for about six or seven years now, and this past year I've really doubled down on improving my skills - built a GameBoy emulator, worked on distributed systems in Go, did Advent of Code. I'm way past the "complete beginner" stage, but my knowledge is pretty uneven. You know how it is when you're self-taught - really deep in some areas, embarrassing gaps in others.

Building Real Things: Zettelgarden

This brings me to Zettelgarden, which I've been building for the last year and a half. It's been an interesting journey because it highlights all the classic problems people like me run into. You know exactly what you want to build, but getting there is another story. You need two lines of actual business logic, but first you have to write 300 lines of boilerplate just to get the routes working. I've tried different frameworks - Flask, Django, Next.js - but they all have the same fundamental issues.

I built most of Zettelgarden with ChatGPT's help, which was great, but had its limitations. Copy-pasting code back and forth gets old fast, and trying to give it enough context about your codebase is a pain. That's why I've been experimenting with tools like Cursor that integrate directly with your code.

Amplifying Developer Output

Here's the thing about AI coding tools that I find fascinating. Think about how much a developer can actually produce at different skill levels - the actual output in terms of working features, apps, and value created. Traditionally, there's a long plateau where you're competent enough to build things, but everything takes significant time and effort. You might know exactly what you need to build, but getting there involves writing hundreds of lines of boilerplate code.

But AI tools change this output curve dramatically. They let you produce more with the same level of skill, helping you skip past the tedious implementation details and focus on building what matters. Look at the graph - the red line shows how these tools can amplify your output even before you hit that senior developer level.

To be clear, this isn't about replacing learning or understanding - you still need to know what you're doing. The tools won't make you a senior engineer overnight, but they can help you build things that would normally require much more experience. For someone like me, coming from a non-traditional background, that's been a game-changer. It means I can focus on the unique aspects of what I'm building instead of getting bogged down in boilerplate and common patterns.

A Real Example: Redesigning the Landing Page

Let me show you a concrete example of what I mean. My landing page was... well, let's be diplomatic and say it needed work. I'd originally built it with ChatGPT, and while it functioned, it looked like something from the early 2000s.

I decided to give Cursor a shot at redesigning it, and got this as an output:

The difference is pretty dramatic, right? And this took minutes, not hours or days. Sure, it doesn't perfectly match the design system in the rest of my app (that's one downside to AI-generated code), but it's way better than what I had before. Sometimes "good enough right now" beats "perfect eventually."

The best part is that I only had to put minimal effort into actually getting this result. Here is my first prompt to Cursor:

Unlike the old days (the halcyon days of early 2023), I didn’t need to ‘engineer’ a prompt, all I did was tell it what I wanted.

It’s even able to run code itself, although I have it configured to require me to click “run”. In this particular instance, it didn’t work out. It tried running npm to install a new package, but ended up installing it globally (because it ran the command in the wrong folder). Then, it went off the rails a bit and wanted to use yarn to install it. At this point, I ran the command myself and it was happy. This just goes to show you that it needs a watchful eye.

After updating the landing page, I wanted to add a couple more features - a Twitter icon and a section showing my most recent blog posts. The Twitter icon was trivial - Cursor even generated the SVG for me. The blog integration was trickier though. It needed to understand how my blog system worked, find the right files, and integrate with existing code. I just pointed it at my blog folder and it figured it out. The code worked on the first try.

This is exactly the kind of task that would normally eat up hours of my time - reading docs, testing different approaches, debugging integration issues. Instead, it took a few minutes. Is it perfect? No. But it's a massive improvement that let me move on to more interesting problems.

Not a Shortcut for Learning

While these tools are powerful, I think Cursor and similar code generation tools are unsuitable for beginners. The reason is simple: you need enough knowledge to guide the tool and understand what it's producing. It's like the difference between a hammer and a nail gun. A hammer might be slower, but it helps you feel every nail going in and understand what's happening. A nail gun is faster and more efficient, but you need to already know what you're doing or you can make some serious mistakes.

This is where I see a key distinction: chat interfaces like ChatGPT are great learning tools. They can explain concepts, help you understand errors, and guide you through problems step by step. You need to understand the fundamentals - how to structure code, basic patterns, debugging approaches - before you can effectively guide and verify what the AI is producing.

The power of these tools isn't in avoiding learning - it's in amplifying what you already know. They're most effective when you can say "I know how to do this, but I want to do it faster" rather than "I don't know how to do this at all."

The Future is Already Here (Just Unevenly Distributed)

You know that William Gibson quote about the future being here, just not evenly distributed? I think that's where we are with AI coding tools. They're not magic - as you saw with my npm/yarn adventure, they still need a human at the wheel. But they're changing what's possible for developers like me who came to tech through the scenic route.

A few years ago, building something like Zettelgarden would have been a massive undertaking for someone with my background. The gap between "I know what I want to build" and "I can actually build it" was huge. Now? That gap is shrinking fast. These tools let me focus on the interesting problems - the actual features that make Zettelgarden unique - instead of getting bogged down in boilerplate and basic implementations.

Is it perfect? No. Sometimes the code isn't as elegant as what a senior developer would write, and you might sacrifice some consistency for speed. But for many of us, that's a reasonable trade-off. Perfect is the enemy of shipped, after all.

The real power here isn't just about writing code faster - it's about lowering the barriers to building real things. And for someone who took the scenic route into tech, that's pretty exciting.

If you're interested in seeing what a non-traditional developer can build with AI assistance, check out Zettelgarden (https://zettelgarden.com) or review the source code on Github . Stars and feedback welcome.