https://manuel.kiessling.net/2025/03/31/how-seasoned-developers-can-achieve-great-results-with-ai-coding-agents/ Skip to Content * Home * About * Projects * Books The Log Book of Manuel Kiessling The Log Book of Manuel Kiessling Covers topics on architecting, building, deploying and running software and systems for the web based on open source tools with lean methodologies. Senior Developer Skills in the AI Age: Leveraging Experience for Better Results Posted on 2025, Apr 03 * 13 mins read There is a lively discussion about this post over at HackerNews: https://news.ycombinator.com/item?id=43573755 I've integrated some of the points made there into this article. Introduction Over the past few months, I have been experimenting with AI-powered coding tools in both my personal and professional projects. The experience has been overwhelmingly positive, both for me and my team of software engineers at work. We've achieved better results in less time, and in many cases, the quality of our output has significantly improved. Interestingly, this experience contrasts with the feedback I've received from some fellow software developers who report that AI tools aren't working well for them. I'm now convinced that AI-assisted software development has the potential to elevate our craft to the next level in terms of productivity. This is why I believe our community should embrace it sooner rather than later -- but like all tools and practices, with the right perspective and a measured approach. My motivation for sharing these experiences and the best practices I've identified is to help move the needle forward in terms of AI adoption within the broader software development community -- even if realistically, it's only by some micrometers. The Current State of AI Coding My Twitter feed suggests that AI-powered coding tools are already generating significant buzz in a specific niche: non-professional developers who are having great fun building software products. For them, these tools primarily serve as enablers, allowing them to tackle projects they might never have considered without such assistance. More power to them -- it's exciting to witness their journey of struggles and breakthroughs. However, this represents just one segment of potential users, and certainly not the only group for whom these tools can provide immense value. The Senior Developer Advantage My current conclusion, though preliminary in this rapidly evolving field, is that not only can seasoned developers benefit from this technology -- they are actually in the optimal position to harness its power. Here's the important part: The very experience and accumulated know-how in software engineering and project management -- which might seem obsolete in the age of AI -- are precisely what enable the most effective use of these tools. That's because while I haven't found the perfect metaphor for these LLM-based programming agents in an AI-assisted coding setup, I currently think of them as "an absolute senior when it comes to programming knowledge, but an absolute junior when it comes to architectural oversight in your specific context." This means that it takes some strategic effort to make them save you a tremendous amount of work. And who better to invest that effort in the right way than a senior software engineer? As we'll see, while we're dealing with this new, cutting-edge technology, it is the time-tested, traditional practices and tools that enable us to wield this new capability most effectively. Three important measures for a successful AI coding session I've identified three critical measures needed when working with AI-assisted coding: * Well-structured Requirements * Tool-based Guard Rails * File-based Keyframing Before diving into these concepts, let me share some real-world examples of how I've used AI in my projects. I will give examples for two categories of projects: green-field and brown-field. For both categories, I'll focus on cases where AI handled the entire implementation, or very nearly so. While I do sometimes use AI as a "better autocomplete" or as a chat-only companion for general discussions, this article focuses on the "real deal" -- where AI tooling operates in an agentic mode and handles all the heavy lifting. For this, my current tool of choice is Cursor, powered by Anthropic's Claude Sonnet 3.7 model. Cursor provides the crucial capability to directly edit all files in a project that require changes, and to execute commands related to the software development process. Example 1: Platform Problem Monitoring Cursor and Claude, combined with the expertise areas I'll discuss below, enabled me to create and fully implement a green-field application: Platform Problem Monitoring. You can find the source code at https://github.com/dx-tooling/ platform-problem-monitoring-core. The application connects hourly to our ELK stack's Elasticsearch server, reads the latest error messages, and sends us a well-formatted email summarizing the current state of problems on our web platform: Platform Problem Monitoring Email Report For more details, check out the "New project: Platform Problem Monitoring" post. In this case all of the implementation logic was written by Cursor/ Claude, requiring no manual code intervention from my side. This is especially noteworthy because I don't actually know Python. Yes, with 25+ years of software development experience, I could probably write a few lines of working Python code if pressed -- but I don't truly know the language. I lack the muscle memory and intimate knowledge of its conventions and best practices. However, my broad understanding of software architecture, engineering best practices, system operations, and what makes for excellent software projects made the development process remarkably smooth. Context on Code Quality: The HackerNews discussion included valid critiques regarding the code quality in this specific Python project example (e.g., logger configuration, custom config parsing, potential race conditions). It's a fair point, especially given I'm not a Python expert. For this particular green-field project, my primary goal was rapid prototyping and achieving a working solution in an unfamiliar stack, prioritizing the functional outcome over idiomatic code perfection or optimizing for long-term maintainability in this specific instance. It served as an experiment to see how far AI could bridge a knowledge gap. In brown-field projects within my areas of expertise, or projects demanding higher long-term maintainability, the human review, refinement, and testing process (using the guardrails discussed later) is necessarily much more rigorous. Example 2: Process Management UI Integration While I can't share the source code for this brown-field example, it demonstrates a different yet equally valuable use case: I had a legacy PHP/Symfony application with a "backend-only" process coordination feature -- think service classes, enums, Doctrine entities, and CLI commands running via cron. While functional, it lacked a user interface. Though not strictly necessary, having a web-based view of this process coordination feature would be valuable -- allowing users to monitor current operations, investigate failures, and manage process execution. For strategic reasons, I wanted this UI to live in our newer application -- the one with the better-designed codebase, more recent framework versions, improved testing capabilities, and superior frontend architecture with a comprehensive living styleguide. The task involved: * Integrating the legacy and new applications via HTTP API * Implementing data transfer between systems * Creating an intuitive UI that aligned with our design system * Building a generalized API client in our shared Symfony bundle Once again, the AI agent implemented this entire feature without requiring me to write any code -- with the exception of keyframe files , as we will see -- manually. Key Insights from Both Projects These examples highlight two distinct advantages of AI assistance: 1. In the green-field project, I could create a functional application despite unfamiliarity with the tech stack (though, as noted, expert review would be needed for production-grade quality). 2. In the brown-field project, I achieved results much faster -- particularly valuable since UI development isn't my strong suit. This was when terms like "game-changing" started to feel appropriate, and I began to recognize this technology's significance for both personal and team productivity. Let's now examine the three measures I employ to ensure productive AI coding sessions that consistently deliver successful results. To repeat myself: achieving significant time savings with AI requires some upfront investment. This parallels managing talented but junior developers -- you can't simply tell them to "build X" and expect optimal results. You need to invest time in setting them up for success. Well-Structured Requirements The foundation of any successful AI coding session is a comprehensive set of requirements. For the Platform Problem Monitoring project, I created this document before starting: REQUIREMENTS.md. At 371 lines, it's substantial, but more importantly, it follows a clear hierarchical structure: * Top-level: Core requirements in one line * High-level: Use case and motivation * Mid-level: Process and work mechanisms * Mid-level: Architecture, tech stack, and constraints * Low-level: Detailed process steps The low-level section breaks down the application's operation into 12 distinct steps, each with clearly defined inputs, outputs, and side effects. Just as this structure guides human developers effectively, it provides the AI assistant with the framework it needs to deliver solid results. You might think creating such documentation required quite some work. And you're right. But it's a necessary investment for a successful outcome. In this context, one of my favorite software development maxims is: "Six weeks of implementation easily save you two hours of planning" The sarcasm highlights an essential truth: the implementation phase is the most expensive place to compensate for inadequate planning. That's why I always encourage my team to start a project at the whiteboard with their product manager, and not at their keyboard. This principle applies equally well to AI collaboration. Another important bit with regard to requirements: I start each Cursor session in "Ask" mode, requesting the AI to: 1. Summarize the requirements in its own words 2. Create an action plan 3. Ask clarifying questions Only after this validation step do I switch it to "Agent" mode and let it begin the implementation. Tool-Based Guard Rails While requirements define the destination, tool-based guard rails ensure we take the most direct route there. Consider how we value real-time feedback systems in development. Nothing is worse than discovering a missing null check through a customer service complaint weeks after launch. Static analysis tools that catch issues during development are invaluable -- and they're just as valuable for AI agents. This is why I prioritize setting up comprehensive quality tools before starting AI sessions. The Makefile for our Python project demonstrates this approach: * Code formatting with black and isort * Linting with ruff * Type checking with mypy * Security analysis with bandit * Comprehensive test suite The AI understands these tools and uses them effectively. When a change breaks type checking, it automatically adjusts its implementation to maintain compliance. I also ensure the AI can validate the functional aspects of its work. For API implementations, I provide curl commands so it can test its endpoints directly. Watching the AI use and refine its own code is remarkable. File-Based Keyframing While AI agents excel at creative problem-solving, sometimes we need to constrain that creativity, especially regarding code organization. This is where file-based keyframing comes in. The technique borrows from animation studios' workflow, where master animators create key frames -- crucial moments in an animation sequence -- while junior animators fill in the intermediate frames. This approach maintains quality while optimizing resource usage. Platform Problem Monitoring Email Report This is why, when working with AI, I create "empty hull" files in the codebase before editing begins. For example, in our brown-field project, the AI needed to implement various components: * an API endpoint * an API client * a Controller class * a Twig template and so on. Instead of letting the AI decide file locations and names, or specifying these details in prompts, I create minimal stub files: