Software is hierarchy
A respected engineering colleague once told me that the hallmark of an exceptional software engineer is that they can create a great document outline. Software engineering is a profession that requires humans to become adept at thinking like machines – organized, hierarchical, logical. It requires a certain knack for creating a mental hierarchy of actions and reusable relationships that the human then expresses as code so the machine can correctly interpret the will of the engineer. Designing, writing, testing, and releasing code, even managing code projects, is really just the process of finding a suitable theme, breaking it down into critical points, and elaborating on each of those features in smaller increments through whatever lens is required. The more meticulously this task is done the more easily and more accurately it can be handed as a task to a computer.
Humans struggle with hierarchy
The difficulty with software development is that it’s hard, after the first few features are developed, to keep all the parts in your head, and therefore to best expand and extend them. In this new era of automation, metrics, patterns, and frameworks, particularly with a large or distributed development team, the hierarchy of instructions becomes convoluted and branched. It becomes less obvious with each iteration where and how to introduce new code. Over time, a whole host of productivity tools (software for building software) have evolved to help track feature progress and delivery, cue developers where their useful components live and how to call them, support devops engineers in releasing software, help interface designers to communicate sophisticated multistep interactions, help testers to repeat tests, help to orchestrate and deliver sophisticated dependencies, etc. The benefits of AI in this sector are to look at the content of the code, the patterns, the timelines and problem-solving techniques used in any development team as a dataset that will improve workflows and developer experience by acting as a very organized, very retentive team member.
Software is good at remembering, and repeating; AI is good at interpreting
While the software industry has had tooling such as automated test runners and continuous integration systems for many years, the introduction of Language capable software has expanded our notion of how software tools can be used to make software engineers more productive. One of AI’s most noticeable contributions to software development is the rise of AI-powered coding assistants. These tools help developers write code more efficiently by making code suggestions, generating autocomplete for half written lines of code, or even anticipating and performing code generation for entire functions.
The popular Github CoPilot from Microsoft is now a standard in this area, suggesting bodies of functions, or writing new ones based on a description. This product treats both comments and the programming language of choice as part of it’s large language model (LLM), and developers who use it regularly will likely find their quantity and quality of documented code is dramatically increased because CoPilot will actually insert very reasonable documentation of the written code, or even write it beforehand based on a short description of the intention, comment-driven-development style. Released in 2024, this solution is actually becoming an older contribution in AI-years. Other vendors quickly followed suit with general llm coding solutions such as Anthropic’s Claude, or IBM’s WatsonX, or more single-use-case solutions such as Amazon CodeWhisperer, which is optimized for building AWS sites. By and large these assistants continue to follow the ‘code completion, documentation, or explanation’ assistant style.
A newer flavor of AI development is what I describe as the Pair Programming Agent. This more sophisticated agent includes solutions such as Cursor, Langchain, Windsurf, and others, including the latest release of CoPilot, with the introduction of ‘Agent Mode’. The developer experience with these agents present more like chatbots that engage the developer in a dialog. They distinguish themselves by resembling a pair programming partner with an excellent memory but rudimentary coding skills. For the agent to work effectively, you need to provide it with background context and tool rule sets that specify your code base architecture, coding conventions and frameworks. The ai-generated code that results from agent interactions can be incrementally reviewed or applied wholesale in you-only-live-once (YOLO) mode and the developer can just it’s quality while observing how the compiled program runs.
While the first suite of generative coders relied on retrieval augmented generation (RAG) algorithms to enhance coding correctness, this method tends to require a lot of background documentation and can slow the agent down. Newer products, like Cursor, use an API known as a Model Context Protocol (MCP) service to provide the codebase background and rules. The AI system can often help software developers to write these rules documents and set up the server. These newer agents can look across a whole code base or even multiple repositories and answer questions about how to build new components within a consistent style (if one is already present), or build up a memory of how to find examples of a pattern within the code, get started on a new problem, identify causes of failing tests, etc. These kinds of agents can be very helpful for engineers working on a solid architecture and rule set. They need to be watched very carefully for hallucinations or just plain poor coding style, which can take more time than it saves if the human engineer is not well versed in the code or design skills.
These newer agents also have the ability to modify large numbers of files and recompile/rerun code, which again is handy when your structure is meticulous and the required code changes are repetitive. This type of workflow can also be helpful if you are refactoring code to follow a new architecture, tooling, or language. If you are breaking new ground with a new feature you may wish to use these agents in a more stepwise fashion, which has the added advantage that it forces the software developer to break down the new functionality into coding tasks to feed to the agent. This up front organization is good practice regardless of whether a human or an AI generates the code.
Software is good at syntax consistency, AI is good at pattern consistency
Another category of software productivity tools that have been around for dozens of years are syntax checkers and testing automation tools. In fact, providing linting rules to the pair-programming agents described above is one important context to provide with MCP. With the advent of software agents that can match functional patterns as well as just spelling and punctuation, AI debugging, automated testing, and deployment orchestration are now a fruitful reality. Suites like Snyk and even CoPilot can write tests and suggest ways to add coverage, Deepseek and others perform analysis of security vulnerabilities and deployment errors even before they happen. SonarQube can analyze static code for bugs and poor performance or architecture, and the latest version of CoPilot can even perform code reviews on the fly (jury is still out on how good these are right now.)
In addition to the obvious benefit of more complete code coverage and platform coverage for different UI configurations, whether that’s in unit tests or integration tests or deployment risk analysis, today’s more sophisticated AI test harnesses can help prioritize tests for dynamic smoke test suites depending on which areas of the code were updated, and can help in maintaining or even self-healing old tests as UI and other named elements change behavior or labeling.
Software is good at organization, AI is good at mining that data
Productivity software isn’t just for engineers. Twenty years of agile project management systems and system monitoring provide a natural transition to the AI enhanced versions. AI-assisted project management automates routine tasks such as improving time estimates, and even helping product and project managers to write better acceptance criteria in their stories. AI-tools allocate resources, schedule tasks efficiently, and monitor system performance in real-time, optimizing deployment and preventing potential failures, scheduling and performing rollbacks, predicting team velocity, and other tasks that keep the team running smoothly.
All of these systems are still at a place where human oversight is critical. These various forms of data and pattern matching are only as good as the training embedded in the AI system. The most powerful generative AI tools today are still only increasingly sophisticated language models. These AI models are good for idea generation and repetitive tasks they have already seen. Generative tools can be guided through MCPs and prompts to allow them to become better assistants for your particular tasks. Engineers, Testers, and Product managers still need to evaluate the results produced, gather ideas or realign them with the overall hierarchy of the system being designed, and optimize the prompting or training patterns so the AI agent can do a better job on the next round.
Software is good at documentation, AI is good at tweening
One of the newest horizons for AI within the software development lifecycle is in the early, open-ended portions of the software development process. Digital tools have existed for many years to allow user experience designers to create mockups, styling, and workflow. In very recent days, it has started to be possible to mine that data for patterns to generate additional views, intermediate frames, more examples of states, and other features that allow a software engineer (or their AI pair programming partner) to instrument all the critical features of that UI, including disabled, transitional, and operational states and all the associated styling, accessibility compliance, and platform compliance. This allows the creative team to focus on ideating the workflow and not generating the huge set of alternatives that can bog down any interface effort.
There are also new AI assistants for product managers that can help bring to life the many states of a software idea in a functional way. A rush of no-code or low-code tools are doing for software development what Openai and chatgpt have done for writing. Tools like Lovable, Bolt, and others allow non-coders or coders who want to make rapid prototypes to share with stakeholders to create operational software by describing the use cases and workflows in natural language. Use of AI tools for creative team members can enhance developer productivity and engagement significantly. Agile stories that are well written with detailed acceptance criteria, UI specifications that handle all of the use cases, and a functional reference implementation that can be mined for code snippets and performance metrics will reduce code completion time and streamline the development process. These tools help produce a result that closely aligns with expectations and requirements the first time, and help stakeholders with rapid decision-making.
Which brings us back to the original premise of this discussion, that good organization and rigorous attention to subdividing software into bite-size functional descriptions is the key to success in software development. The process of breaking down a desired software implementation into incremental parts is exactly the process that is most likely to produce a successful implementation from a no-code system. Lovable’s Prompt Engineering documentation bears a striking resemblance to an English class guide for developing an outline for a research paper. This type of creativity tool is offering ‘code democratization’, meaning that anyone can create software with it without being trained as a programmer. While that is true on the surface, I believe that it is more correct to say that it distills the intellectual skills necessary to produce software, those of clarifying down to a very granular level of detail what must happen in what order and on what trigger, without mixing in the struggle to understand the syntax of a language or the mysteries of a deployment system. AI technologies are still, after all, helping the machine to interpret the will of the human, and still require rigorous definition and workflow in order to be effective.
Software is hierarchy; AI coaches hierarchy
We are still in the early stages of the era of AI agents, AI metrics and devops, and no-code development. All of AI assistant categories described above are, as the label implies, assistants. Developers, testers, deployment engineers, and program managers will state plainly that none of these technologies can be used without careful intervention and oversight from an experienced practitioner. In fact, the developer experience with each of these technologies is decidedly mixed at the moment. If the hierarchy and plan of use is well spelled out, your results may be good. This is particularly useful if the product you are working on is long-running, has a robust structure, and requires a series of incremental improvements. But just as many experiences, particularly when introducing new feature or technology types, reveal the generated code to be full of hallucinations or just plain poor architecture. The AI workflow may reveal flaws such as removing code it’s just inserted, reporting errors that don’t exist, or creating new code that does not compile. It’s best to consider the AI not as a developer (or a tester, or a designer), but rather as an editor or a coach.
The same is true if you are using AI to help write an article (like this one) or create a presentation. An article written with a single discussion prompt to chatgpt is likely to be boring, stilted, and wander off topic. But when the thesis is built incrementally in a structured way, the dialog between AI and human can produce a better result than writing alone. In the case of AI within the software development lifecycle the structured approach required to make the AI helpful will also encourage the human practitioners to refine their work style. This process of conducting AI code reviews and monitoring metrics such as up-time, code coverage and security audits is enhanced by having a virtual team member in the loop that constantly encourages these practices, sometimes just by virtue of requiring that consistency and meticulousness in order to work. There has been industry speculation that AI will wind up replacing junior engineers and reduce the learning opportunities that younger members of the software team need in order to gain experience in craft. I believe rather that these AI tools, when applied productively in a workflow, hold everyone on the team to a higher standard, will provide more productive reflection on the purpose and actions of the software at the start of a project, and more rigorous deployment strategies as it evolves. Used thoughtfully as a coach and an editor, AI software development tools can bring a renaissance to the industry.
