https://yasint.dev/we-might-all-be-ai-engineers-now/ / yasint We Might All Be AI Engineers Now March 05, 2026 ai, engineering, tools, agents I enjoy writing code. Let me get that out of the way first. The problem solving, the architecture decisions, the feeling when something clicks into place. That hasn't changed. What has changed is everything around it. Lately I've been spending most of my time writing agents and tools. Building systems that supervise AI agents, training models, wiring up pipelines where the AI does the heavy lifting and I do the thinking. Honestly? I'm having more fun than ever. Everyone knows the models are good now. That's not news. But most people still miss the point. They see AI-generated code, call it slop, and move on. Sure, unguided, it is slop. But guided? The models can write better code than most developers. That's the part people don't want to sit with. When guided. When you know what you want. When you know what architecture to reach for. When you understand the tradeoffs and can articulate them clearly. The game goes on easy mode. I'm building something right now. I won't get into the details. You don't give away the idea. But it involves concurrent graph traversal, multi-layer hashing strategies, AST parsing, and file system watchers all wired together. That's not a weekend hack. But the AI is writing the traversal logic, the hashing layers, the watcher loops, while I design the architecture and decide how the system should behave when state changes propagate. I'm shipping in hours what used to take days. Not prototypes. Real, structured, well-architected software. Debugging? Debugging is on steroids now. I run multiple agents at once, feed them my thinking. Here's what I suspect, here's where I'd look, here's what doesn't make sense. They fan out and dig. It's like having my problem-solving instincts multiplied across five brains at the same time. I still drive the intuition. The agents just execute at a speed I never could alone. I haven't written a boilerplate handler by hand in months. I haven't manually scaffolded a CLI in I don't know how long. I don't miss any of it. The problem is: you can't justify this throughput to someone who doesn't understand real software engineering. They see the output and think "well the AI did it." No. The AI executed it. I designed it. I knew what to ask for, how to decompose the problem, what patterns to use, when the model was going off track, and how to correct it. That's not prompting. That's engineering. When someone without that intuition tries the same thing? They get spaghetti. Code that compiles but doesn't scale. An architecture that falls apart the moment you add a second requirement. The model doesn't save you from bad decisions. It just helps you make them faster. The skill isn't writing code anymore. The skill is knowing what to build and how it should work. The code is just the output. I'm not worried. I can still reverse a binary tree without an LLM. I can still reason about time complexity, debug a race condition by reading the code, trace a memory leak by thinking. Because I studied my ass off before any of this existed. That foundation isn't decoration. It's the reason the AI is useful to me in the first place. Without it, you don't know when the model is wrong. You don't know what questions to ask. You don't know what good looks like. Most people underestimate how much that matters. Here's the thing though. That foundation isn't gatekept anymore. You can learn anything now. I mean anything. The resources, the tools, the mentors-on-demand, it's all there. The barrier to entry has never been lower. So if you haven't built that intuition yet, you have no excuse. Start now. If you've spent years building it, understanding systems, understanding architecture, understanding why things break, you're not being replaced. You're being amplified. I think we all might be AI Engineers now, and I'm not sure how I feel about that. What I do know is this: when I look at a team or a workplace, one of the first things I notice now is how they think about AI. Not whether they've adopted every tool, but whether they're curious. Whether they're paying attention, because this isn't a phase. This is the direction. Teams that get it? Those are the ones I want to be on. --------------------------------------------------------------------- Edit -- 2026-03-06T17:06:41Z: This post got some great discussion on Hacker News, and a lot of the pushback was fair. So I want to clarify a few things. I'm not vibe coding. Every line of AI-generated output gets reviewed. Every statement. If I don't understand what it's doing, it doesn't ship. That's non-negotiable. There's a line between using AI well and blindly delegating to it. For me that line is scope. Small, well-defined tasks with verifiable output? That's where agents shine. But when the problem requires deep context about the system, the kind of knowledge you only have from working in it, I'm faster doing it myself. Knowing when to use the tool and when to put it down is half the skill. I also want to be clear about something: everything I know, I learned from people. Senior engineers who reviewed my rough pull requests. Colleagues who took the time to explain why my thinking was off. Books. Feedback. Years of writing bad code and slowly understanding why it was bad. That foundation is the reason AI is useful to me now. Without it, you can't tell when the model is wrong. You can't course-correct what you don't understand. I look at code I wrote 10 years ago and I'm humbled by how far off I was. But that struggle is exactly what built the intuition. We studied fundamentals for a reason. That reason didn't go away just because the tools got better. Well, now what? You can navigate to more writings from here. Connect with me on LinkedIn for a chat. 1. 2026 1. We Might All Be AI Engineers Now ------------------------------------------------------------- March 05 ai, engineering, tools, agents 2. The Hardest Bug I Ever Fixed Wasn't in Code ------------------------------------------------------------- February 07 engineering, career 3. Why I Switched to Podman (and Why You Might Too) ------------------------------------------------------------- February 02 docker, tools, linux 2. 2024 1. The World is Stochastic ------------------------------------------------------------- October 18 career, philosophy 2. Debugging a running Java app in Docker ------------------------------------------------------------- May 29 java, docker, debugging 3. Why is it UTC and not CUT? ------------------------------------------------------------- February 21 time, history 3. 2023 1. Deep prop drilling in ReactJS ------------------------------------------------------------- December 26 react, javascript, frontend 2. Eigenvectors ------------------------------------------------------------- October 24 math, linear-algebra 3. Java's fork/join framework ------------------------------------------------------------- October 21 java, concurrency 4. TypeScript's omit and pick ------------------------------------------------------------- August 10 typescript, frontend 5. JavaScript's new immutable array methods ------------------------------------------------------------- June 28 javascript, frontend 6. Integrating JUnit 5 in Maven projects ------------------------------------------------------------- May 25 java, testing 7. My take on ChatGPT and prompt engineering ------------------------------------------------------------- March 11 ai, prompts 8. Declarative events in ReactJS ------------------------------------------------------------- March 09 react, javascript, frontend 9. Positive Lookaheads ------------------------------------------------------------- March 07 regex, tools 10. Functors ------------------------------------------------------------- March 06 functional-programming, math 11. Fast forward videos with ffmpeg ------------------------------------------------------------- January 18 ffmpeg, tools 12. Rotate y-axis of a 2D vector ------------------------------------------------------------- January 05 math, vectors 4. 2022 1. Synchronizing time ------------------------------------------------------------- December 31 distributed-systems, time 2. Vector rotation ------------------------------------------------------------- November 20 math, vectors 3. Sed find and replace ------------------------------------------------------------- November 14 sed, tools, linux 4. Asgardeo try it application ------------------------------------------------------------- September 06 identity, iam, asgardeo 5. Flatten error constraints ------------------------------------------------------------- August 11 java, algorithms 6. Good Git commit messages ------------------------------------------------------------- July 24 git, engineering 7. Asgardeo JIT user provisioning ------------------------------------------------------------- March 09 identity, iam, asgardeo 8. Monotonic Arrays ------------------------------------------------------------- February 25 algorithms, javascript 9. How GOROOT and GOPATH works ------------------------------------------------------------- February 01 go, tooling 5. 2021 1. Two summation ------------------------------------------------------------- November 21 algorithms be consistent. only dead fish go with the flow.