The AI Shift in Software Dev

The AI Shift in Software Dev

How AI Is Becoming a Developer’s Everyday Assistant

And how I used it to build a fully working retro-style text adventure engine in just 7 hours

A year ago, I was skeptical.

AI was starting to show up in developer tools, and while the buzz around it was huge, it didn't take long for me to hit its limitations. Hallucinations, irrelevant code, broken logic—I spent more time verifying outputs than actually getting help.

Still, I was curious enough to experiment. I started using AI cautiously, keeping expectations low and treating it like a sidekick—not a replacement.

Since then, things have changed.

In just one year, AI has gone from being an unreliable assistant to a tool I can trust to scaffold entire projects. And to prove it to myself, I put it to the test with something I’ve been meaning to build for over a decade: an interactive text adventure engine.

Here’s how it went—from concept to working prototype—with full transparency on what AI did well, where it fell short, and what this means for the future of developers like me.

My First AI Steps: From Curiosity to Code

When AI tools first became practical for developers, I started using them as a smarter way to read documentation. Instead of digging through endless pages, I could just ask a question—as if I were talking to a well-informed colleague.

Then I started getting bolder: asking AI to write small code snippets—utility functions, helper scripts, one-off logic. Simple stuff I could plug into my projects.

Early on, the results were… underwhelming. Hallucinated answers cost me time and confidence. I had to double-check everything, which erased much of the time I hoped to save. The code didn’t consider the full context or all use cases, and integrating it often took longer than writing it from scratch.

That was my starting point—about a year ago. And since then, the tech has grown fast.

The Shift: AI Gets Smarter

In the past year, models have become significantly more accurate, helpful, and context-aware. Hallucinations are rarer, and the code they produce is cleaner and closer to something I’d actually use.

Even in large tech companies, AI is now generating a significant portion of code—but crucially, that code doesn’t go live on its own. Human engineers are still in control—reviewing, managing, and integrating AI-generated output into real systems. They're not writing every line anymore, but they're responsible for making sure the right code ends up in the right place.

This marks a broader shift in how we work. Think back to when we moved from low-level languages to high-level ones, or from building everything from scratch to using frameworks and libraries. Each step automated some manual work—but raised the bar for architectural thinking and problem-solving.

AI is just the next abstraction layer. Developers are moving from coders to orchestrators—focusing more on direction, validation, and integration than on raw typing.

And this isn’t just happening in Silicon Valley. I know a small company in northern Italy where developers work with AI every day—scaffolding new features, reviewing the output, and shipping production code through this collaborative process. This evolution is already underway across teams of all sizes.

That got me thinking: If AI is really this capable now, what could I build with it—on my own, from scratch, in 2025?

The Project: Zorint.lab

More than ten years ago, I had an idea.

I wanted to build an interactive text adventure engine—something retro-styled like Zork, but structured around a JSON-based scenario format. The vision was a command-line style game running in the browser, handling:

  • Room movement
  • Interactions with objects
  • Encounters with monsters and NPCs
  • Utility commands like “help”
  • A terminal-style interface with light visual transitions

At the time, I imagined building it with jQuery (yes, it’s been that long). But I never got around to it.

The Experiment: Letting AI Do the Heavy Lifting

Now that AI has matured, I figured I’d finally build it—but with a twist. I would let AI write all the code, and I’d measure how much time it took to deliver exactly what I wanted.

To make it more fun, I wrote the first adventure myself: it’s based on Sorint’s HQ in Grassobbio. The story follows a new Sorintian exploring the office for the first time. You can move between rooms, talk to colleagues, interact with objects, and fight bugs (literally—some are monsters).

I called the project Zorint.lab, a nod to Zork, one of the most iconic text-based games ever made.

Updating the Tech Stack

Since jQuery is a relic these days, I rebuilt the vision with a modern tech stack:

  • React.js
  • npm for package management
  • Webpack for bundling

The AI Stack I Used

I used three AI models in different roles:

  • OpenAI o4-mini-high – For initial project setup, architecture and first JSON generation
  • OpenAI GPT-4o – For small fixes, tweaks, clarifications and JSON updates
  • Claude 3.5 Sonnet (via IDE integration) – For code adjustments and JSON updates

The Process: From Nothing to Working Prototype

Once I defined the structure and got the initial codebase running, I hit a small roadblock: I didn’t have a JSON adventure file to test with. So I asked the AI to generate one.

In just a few prompts, I had a working game.

I could move between rooms, fight enemies, and use commands—all inside the terminal UI. The result blew me away. It was working faster than I expected.

The UI, however, was basic. So I asked the AI to redesign it into a sleek terminal interface with smooth animations. That version—the one you can now try out online—is entirely AI-implemented. It looks great and adapts beautifully across screen sizes, from desktop to mobile.

At first, I wrote the JSON manually. But soon I realized I could just define the corridors, and the AI could auto-generate all rooms, descriptions, and movement logic. That alone saved me 2–3 hours.

When it came to monsters, NPCs, and interactive elements, I collaborated with the AI: I’d sketch out the idea, and the AI would help flesh it out—suggesting behaviors, descriptions, or interaction logic. It was a co-creative effort: half me, half machine. And frankly, it made the process both faster and more enjoyable.

The Results

The experiment worked.

Here’s the time breakdown:

  • AI-driven development + code review: ~3 hours
  • Mapping Sorint HQ into JSON: ~2 hours
  • Designing NPCs, monsters, and interactions: ~2 hours

Total: ~7 hours

Most of that time was spent on creative world-building—which, with the right input, AI could help suggest at a high level. But meaningful contributions still required my direction.

Lessons Learned

Would I do it again? Absolutely—but with some lessons in mind:

  • You still need strong fundamentals. AI gives you a shortcut, but you must know how to evaluate and integrate what it produces.
  • Prompting is a skill. The better you guide the model, the better the result.
  • Time is saved on execution, not decisions. AI helps with the how, but you still own the why.
  • Creativity thrives with AI. It didn’t get in the way—it enhanced the process.

Final Thoughts: AI Isn’t Replacing Developers—It’s Evolving the Role

There’s a lot of talk about AI taking over jobs, and developers are often at the center of that conversation. But if history is any guide, new tech rarely replaces us—it changes the game.

AI is already a powerful tool for delegation, productivity, and speed. Today, it’s something we use to work smarter. Tomorrow, it might simply be how software gets built.

And honestly? I’m okay with that.

Try the game here: Zorint.lab - your first day.

Prev Next