AI, Code, and the Art of Not Knowing Things

A Love Letter to Libraries

There’s a certain kind of joy in not having to know things.

I’ve been writing C# for most of my career, and I still remember the early days of working with files. FileStream, StreamReader, using statements, and all the boilerplate that came with it. Then one day, I stumbled across File.ReadAllText(), a single line that did all the work I’d been sweating over.

It felt like discovering a magic spell. Or maybe just good design. Either way, it was my first taste of real abstraction. The kind that saves you from having to know exactly how something works under the hood.

And that same feeling? It’s back. But this time, it’s not about files. It’s about code itself.

With tools like Claude, Cursor, and other AI-powered coding assistants, I’ve started to notice a shift. I’m no longer thinking about exact syntax or scouring docs for the nth time. I just describe what I want, and the code appears. Or at least something close enough to steer.

These tools feel like the next logical step in software development. Like libraries, they abstract complexity. But instead of wrapping a specific function, they’re wrapping the act of coding itself.

And honestly? I’m starting to think that not knowing things might be the future.

---

The Metaphor: AI as the New Abstraction Layer

When I think about what libraries did for us as developers, it always comes back to one word: abstraction. They took the messy, low-level details and wrapped them up into something clean, predictable, and reusable. I didn’t need to know how the file system actually worked. I just needed to know what File.ReadAllText() did.

Now, with tools like Claude and Cursor, I’m seeing the same kind of abstraction, but on a much broader scale. These tools don’t just wrap specific logic. They help generate the logic itself. Instead of calling a method that someone else wrote, I’m asking an AI to write that method for me. Sometimes it nails it. Sometimes it gives me something weird. But either way, I’m not starting from scratch.

It feels like a shift from writing code to orchestrating code. I tell the AI what I want, and it starts building the pieces. I review, tweak, guide, and sometimes scrap the whole thing and ask again in a different way. It’s less like using a traditional library and more like talking to a very fast, slightly overeager junior developer who’s read the entire internet but never slept.

This abstraction is not just about saving time. It is about changing how we think. I am starting to think more in terms of intent and less in terms of implementation. I still care deeply about architecture, performance, and correctness, but I don’t spend nearly as much time remembering exact syntax or boilerplate patterns.

In a way, AI has become the new abstraction layer. Not over file systems or HTTP requests, but over the act of coding itself.

---

What Changes for Developers?

When I first started using AI tools like Claude and Cursor, I thought of them as helpers. A way to autocomplete a snippet, or generate that one annoying function I didn’t feel like writing. But pretty quickly, I realized the way I was working had changed. Not just the pace, but the mindset.

For one, I don’t pause as often to Google syntax anymore. I’m not digging through old repos to remember how I handled something three years ago. I just ask the AI to write it for me, or at least get me started. Sometimes it gives me a great solution. Sometimes it’s weird, or clearly hallucinated. But the point is, the starting point is no longer a blank file.

I’ve also noticed I spend more time thinking about what the code should do, rather than how to write it. That might sound subtle, but it’s a big shift. When AI is doing the typing, your job shifts to guiding, editing, and evaluating. It’s like being the architect and the reviewer at once.

That’s not always a good thing. I’ve caught myself skimming through AI-generated code too quickly, assuming it works. And occasionally, it does not. You still have to understand what’s going on. The risk of turning into a button-pusher is real if you stop thinking critically.

But when used well, AI takes the pressure off the small stuff. You don’t have to keep a mental cache of every syntax rule or parameter order. It lets you operate at a higher level, like how high-level languages freed us from memory management. Or how libraries freed us from the file system internals.

It’s not that the role of the developer is disappearing. It’s that the role is evolving.

---

From Syntax to Semantics: What Should Developers Focus On Now?

If AI is taking care of the syntax, the boilerplate, and even some of the logic, what’s left for us?

Honestly, the good stuff.

When I don’t have to think about whether I’m using the right casing on a method name, I can spend more energy on what the code actually means. Not just whether it works, but whether it makes sense in the bigger picture. Does it match the business logic? Will it scale? Can someone else read it and understand why it exists?

That shift from syntax to semantics feels like the next phase in how we work. We’re no longer just coders. We’re problem solvers, designers, explainers, and translators between humans and machines.

I still need to know how the code works. But more often, I’m stepping back to look at how everything fits together. When AI writes code, I become the editor. I’m not just checking for bugs. I’m checking for intent.

In some ways, it reminds me of how architects don’t always lay the bricks. They design the structure. They make decisions about how the parts come together. The builders still matter, of course. But the thinking has moved up a layer.

That’s what it feels like to code with AI. Less like typing and more like shaping.

---

Final Thoughts: Embrace the Abstraction

I used to think being a good developer meant knowing everything. Every syntax rule. Every obscure corner case. Every clever trick buried in the language.

Now, I’m starting to think that being a good developer means knowing when to let go of that.

AI is not replacing the need for developers. It’s just raising the floor. The details still matter, but whether it makes sense in the bigger picture matters more. Does it match the business logic? Will it scale? Can someone else read it and understand why it exists?

If that feels a bit scary, that’s normal. But like the Hitchhiker’s Guide says — don’t panic.

Just keep building. Even if you’re not the one typing every line.

First published December 29, 2025 on 42 Insights.