KEY TAKEAWAYS
AI is changing software development less by writing code faster and more by eliminating the investigative work surrounding it. Across AAXIS engineering teams, AI is helping search historical requirements, capture knowledge from legacy platforms, translate designs into tested components, plan implementations, and identify production issues faster.
AI can surface relevant requirements and historical tickets before teams duplicate work or miss dependencies.
AI knowledge bases can preserve critical context around legacy systems, reducing dependence on tribal knowledge.
AI-assisted frontend delivery helped one AAXIS team increase unit test coverage from nearly zero to roughly 60%.
AI can accelerate implementation planning, production triage, and post-release monitoring.
The biggest opportunity is connecting these capabilities across the SDLC to create shorter feedback loops between planning, development, testing, and production.
Human judgment remains essential for architecture, tradeoffs, quality, and decisions about what ultimately ships.
For a few years now, “AI in the SDLC” meant autocomplete. A smarter suggestion in the editor, a faster way to write a unit test, a shortcut around boilerplate. Useful, but marginal. It shaved minutes off tasks that were already fast.
What's happening on our engineering teams right now is a different kind of change. AI has started taking on searching, planning, triage, and quality work that used to require a person to sit with a legacy system, a design file, or a production dashboard and manually connect the dots. Four very different parts of our SDLC show the same pattern: requirements and planning, a legacy commerce platform, frontend delivery, and mobile development. In each case, AI is absorbing the investigative work, and that's where real efficiency is hiding.
What AI Is Already Doing, Today
Start with requirements and planning, usually the least glamorous part of any project and the place where scope quietly goes sideways. Before a new requirement gets written up, someone must ask: has something like this already been built? Is it going to collide with an existing feature? Traditionally, that meant digging through years of tickets by hand. Now AI can search across ten thousand-plus historical Jira or ADO tickets in the time it takes to type the question, and surface anything related before someone starts drafting a duplicate. It can also help slice a big, vague requirement into smaller, ready-to-build stories with clear acceptance criteria. The bottleneck used to be a person's memory of “didn't we do something like this in 2023?” That's mostly gone now – recall my last article about tribal knowledge.
Platform maintenance brings the opposite problem: extensive history, but limited visibility. We maintain a closed-source commerce platform whose original developers have moved on and whose documentation is sparse or unreliable. To close that gap, our team reverse-engineered the compiled code, combined what we learned with the available official documentation, and built a reusable AI knowledge base. This gave AI practical context for a system it could not access directly. We also added an automated release check that compares production logs after each deployment and flags new issues. It provides the kind of safety net that once depended on someone spotting an unusual error buried in a log stream.
Frontend delivery shows what happens when this kind of AI assistance runs for a full release cycle rather than a single task. With the same team and the same schedule, unit test coverage went from close to zero to roughly 60%, a jump that would normally require a dedicated hardening sprint the roadmap can't always afford. Performance work, previously something that got pushed to “next release” when time ran short, became a routine part of delivery instead of a stretch goal. The team even shipped a new internal tool that wasn't considered realistic before. None of this came from writing code faster line by line. It came from AI taking a Figma design and turning it directly into a production-ready, tested component, reading the actual design file instead of guessing from a screenshot, and freeing up the hours that used to go into translating pixels into markup by hand.
Mobile tells a similar story from the operations side. Before a mobile engineer writes a line of code, AI can turn a detailed ticket into a concrete implementation plan: which files to touch, what approach to take, and a checklist to verify against. We still enforce a peer review process before anything ships. When something breaks in production, AI can review the crash signature and stack trace from monitoring data and narrow in on a likely cause before an engineer starts digging. In both cases, the upfront investigation, the part that used to eat the first hour of any task, now happens before the human even opens the ticket.
Where This Is Headed
Right now, each of these wins looks like a point solution: a smarter way to search for tickets here, a platform-specific knowledge base there, a design-to-code pipeline somewhere else. But the trajectory is toward something much more connected and that is so cool. Once AI has durable context on a legacy platform, a design system, and a production environment at the same time, the handoffs between planning, building, and monitoring start to compress. A requirement search that flags a related past incident. An implementation plan that already accounts for how a similar change behaved in production last quarter. A release check that traces a new error back to the ticket that likely caused it, instead of just flagging that something changed.
That's the next level of SDLC efficiency. It isn't faster typing so much as shorter feedback loops between stages that used to be siloed by whoever happened to hold the institutional knowledge. For legacy systems, this matters even more than it would for a green-field product. The hardest part of maintaining an old platform has never really been the code. It's the knowledge that lives in a few people's heads and sometimes walks out the door when they leave. An AI knowledge base built from the actual system, and kept current, is a hedge against exactly that risk.
It also changes how we should think about measuring impact. Frontend's roughly 60% coverage improvement is a real, tracked number, the kind of before-and-after data every team should eventually have. The other teams described here report the same shape of benefit: faster fixes, broader coverage, less manual digging. They just don't have it in a spreadsheet yet. Closing that gap and being honest about where we have hard numbers versus a strong shared impression, is the next necessary step, even if it isn't a glamorous one.
What Stays Human
None of this replaces judgment. AI can tell you that a requirement looks similar to one from two years ago, but it can't tell you why the business decided to handle that client's contract terms differently, or which of three “reasonable” implementation approaches actually fits how the team wants to evolve the platform next year. It can generate an implementation plan, but someone still must read it, catch the edge case it missed, and decide whether to ship it. It can flag a new error after a release, but a person still decides whether that error is a rollback-worthy problem or just a regular Tuesday.
The teams getting the most out of this aren't treating AI as an autopilot. They're using it to clear away the investigative grind, freeing people up for the calls that were always the actual job: deciding what to build, weighing the tradeoffs, and staying accountable for what ships. AI can find the ticket, draft the plan, and flag the anomaly. Someone still must decide what any of it means.
How We’re Putting This Into Practice at AAXIS
At AAXIS, this isn’t a prediction about the future of software development. It’s how our teams are working today. We’re applying AI across our own SDLC and bringing what we learn directly into our client work, from modernizing complex legacy platforms to building new digital and AI capabilities. The goal isn’t simply to use more AI. It’s to build better software, move faster, reduce risk, and ultimately deliver better business outcomes.