Engineering with AI: The Shift from Execution to Strategy

During the early AI boom, I was quite skeptical about its application in software engineering. At the time, my primary concerns revolved around how models would understand large code contexts, how to manage data security, and how reliable generative AI actually was. Looking back around three years later, the technology has evolved tremendously. Honestly, the pace of AI development has surprised me. Even as someone working in tech, it can be difficult to keep up with the latest updates. Here, I want to reflect on my adaptation as a software engineer, the results I've seen in my company Techflouu, and the ultimate impact from a business perspective.

Early Adoption

During my early adoption around 2023, I primarily interacted with generative AI through the ChatGPT interface. The tasks I assigned to it were mostly focused on improving my day-to-day productivity and handling repetitive chores. AI acted as my pair programmer, helping me review code, fix bugs, and write documentation. However, integrating AI directly into our core coding workflow was limited at the time because the models were highly prone to hallucinations. This timeline matched the initial booming popularity of GPT, as people suddenly realized that generative AI was going to have a massive impact.

Around this time, our team also wanted to leverage AI to solve actual business use cases. We built prototypes for creating workout routines, generating meal plans, and handling medical report OCR (Optical Character Recognition). At this stage, the biggest concerns were consistency and reliability. I clearly remember a flaw in the meal planning application where the model kept suggesting salmon recipes, even when the user explicitly declared they were vegan. Because of these limitations, even simple use cases required specific fine-tuning. Although these early prototypes never made it to live production, they became the foundation for what we built next.

Model's Improvment

By 2024, I noticed a massive leap in the model's capabilities. For general use cases, fine-tuning was no longer a necessity. Simple prompt engineering could solve the problem. Around this time, a team member suggested I try an AI-powered IDE, which led me to use Cursor for the first time. The IDE dramatically assisted with autocomplete and quick fixes. More importantly, the system understood the broader context of our codebase. Previously, when using a chat interface, I had to manually paste and explain a lot of context to get an accurate result. Now, I only needed to explain my high-level execution plan. AI also began taking over a significant portion of our automated testing. Consequently, the amount of time I spent writing code line-by-line was drastically reduced. I started adjusting to my new role acting as a supervisor reviewing the AI's output.

After multiple iterations, we finally shipped a stable, production-ready AI product. Our team launched an AI-based food recognition feature that analyzes images, lists ingredients, and calculates nutritional values. In our final iteration, we enhanced the feature with user-behavior consistency . For example, if a user snaps a photo of yogurt and manually corrects the AI ingredient result to "No Sugar Yogurt," the AI remembers this preference. The next time they take a photo of yogurt, the system automatically logs it as "No Sugar Yogurt." Meanwhile, another team in our company successfully implemented RAG (Retrieval-Augmented Generation) to power a personalized job recommendation engine.

Agentic AI

Eventually, we transitioned into the era of Agentic AI. Around 2025, I began exploring the possibilities of integrating autonomous AI agents into my workflow. The idea of letting an agent complete tasks independently was quite daunting at first. To mitigate this, I started small. I asked the agent to fix isolated bugs, meticulously guiding it on exactly which files to read and edit. Over time, I graduated to larger features that required multiple iterations of planning and execution. This journey forced me to familiarize myself with a new paradigm, learning concepts like tool calling, MCP (Model Context Protocol), and agentic loops. The models' grasp of code context had improved so much that, when combined with careful architectural planning, hallucinations could be significantly reduced.

Our company successfully built prototypes for an agentic workflow, including an expense report bot and a personal assistant bot. This huge leap was mostly caused by AI companies launching advanced reasoning models. However, from a business perspective, we faced hurdles beyond the code itself. For several clients, we realized we had to modernize their internal data ecosystems before any agentic workflow could be implemented. Another ongoing challenge is change in management to help staff members adapt to an AI ecosystem and learn to trust an autonomous agent to perform tasks on their behalf.

Conclusion

Looking back at my personal timeline, I noticed that my adaptation curve, the time it takes for me to feel fully comfortable using a new feature in production, is usually about one year after its initial public release. To build deeper trust in agentic workflows, I recently had a conversation with my supervisor about shifting my core responsibilities. The goal is to spend significantly more time on structural planning rather than raw execution. This involves multi-layer planning and rigorous QA, making the models more rigorous QA that interrogates edge cases before a single line of a feature is even built.

Three years ago, my skepticism centered on AI's context understanding, reliability and security. While context understanding and reliability have improved significantly over the past four years, security remains a critical, evolving concern. We are no longer just dealing with traditional data leaks; we are now far more vulnerable to AI supply chain attacks. The broader our AI integration becomes, the larger our attack surface grows.

My concerns have shifted. Not to whether AI can do these tasks, but how we, as humans, adapt our roles, responsibilities, and trust in a world where machines handle complex execution. That adaptation curve, I've learned, might be our most valuable metric.