Over the past year, it has become almost impossible to ignore the speed of change happening around AI-assisted software engineering. Every week there are new models, coding agents, orchestration frameworks, MCP servers, evaluation toolkits, vector databases, agentic runtimes, and entire workflows being rebuilt around LLMs. The space is moving extremely fast, and honestly, one of the most interesting things about it is not the models themselves, but how quickly software engineering workflows are starting to change around them.
Like many engineers, I found myself constantly experimenting: testing models, comparing providers, trying Claude Code, exploring local models through Ollama, reading about agentic workflows, structured outputs, orchestration engines, long-context limitations, evaluation pipelines, and autonomous execution loops. At some point, instead of only reading and experimenting in isolation, I decided to build something practical and run it continuously as a real workflow.
What started as a small experiment around automating job applications quickly evolved into a much larger workflow system. The pipeline now fetches jobs from LinkedIn, filters them using configurable rules and regional strategies, posts summarized job cards into Slack, waits for approval through reactions, generates tailored CVs and cover letters, reviews and scores them, revises weak outputs iteratively, exports recruiter-ready DOCX and PDF documents, and tracks all applications automatically. It also supports multiple AI providers through one abstraction layer and runs continuously using scheduled and watch-based execution modes with persistent state and recovery handling.
The most noticeable thing during this process was the implementation speed. Using Claude Code made execution and iteration extremely fast compared to traditional development loops. Features that would normally require hours of scaffolding, repetitive wiring, refactoring, and documentation lookups could often move from idea to working implementation within minutes. The speed difference is difficult to overstate.
At the same time, the bottleneck shifted upward. Less time was spent typing boilerplate code manually, while much more time went into workflow design, orchestration, validation, context management, recovery handling, and operational safety. The engineering work became less about syntax and more about shaping systems and controlling behavior.
This project also gave me a much more practical understanding of what “agentic AI” actually means. Most discussions online focus heavily on the model itself, but in reality the interesting part is usually the workflow around the model. The LLM became only one component inside a larger stateful system involving queues, approvals, retries, persistence, review loops, tool chaining, and validation stages. The system behaves less like a chatbot and more like an orchestrated autonomous workflow with humans still involved at key decision points.
One of the most important lessons was how critical state management becomes once AI is integrated into long-running workflows. The system maintains fetched job history, deduplication indexes, approval queues, review states, generated artifacts, application trackers, and recovery metadata. Without persistent state and recovery handling, most AI workflows become unreliable very quickly. Generating text is usually the easy part; building reliable systems around generation is where the real engineering complexity starts appearing.
Another interesting observation was how AI-assisted development changes the implementation cycle itself. Instead of manually building every detail from scratch, the workflow becomes much more iterative: design, generate, validate, revise, restructure, test, and repeat. Claude Code became extremely effective at generating scaffolding, restructuring codebases, refactoring repetitive logic, wiring pipelines together, and accelerating experimentation. At the same time, it still required careful engineering oversight. Without discipline, issues such as duplicated abstractions, architectural drift, fragile integrations, and inconsistent assumptions start appearing very quickly.
I also experimented with multiple providers including Claude, OpenAI, Ollama, and Nvidia-hosted models behind a single abstraction layer. The behavioral differences between models were significant. Some were better at structured outputs and long contexts, others were faster or cheaper but less reliable operationally. This started feeling less like “using AI” and more like dealing with engineering tradeoffs around latency, reliability, determinism, context handling, and failure modes.
One deliberate design decision was keeping humans in the loop. The system never auto-applies to jobs. It fetches, filters, summarizes, prepares, reviews, and organizes, but the final decision still belongs to the human. Reliability is still probabilistic, and judgment continues to matter, especially when workflows interact with external systems and real-world consequences.
The biggest takeaway from this project is that AI coding tools are not reducing the importance of engineering. They are increasing the leverage of engineering decisions. Good workflows, clean abstractions, and solid operational thinking compound much faster when AI accelerates execution. At the same time, weak architecture and poor workflow design fail much faster as well.
What changes is not the need for engineering, but the shape of engineering itself. Less time is spent fighting syntax and boilerplate, while more time goes into orchestration, workflow design, validation, system integration, and iterative refinement. And honestly, I think this transition is one of the most technically interesting shifts happening in software engineering right now.