Over the past few weeks, I’ve been deliberately exploring how AI can support real-world software delivery—not as a novelty, but as a practical tool embedded into day-to-day engineering work.

This hasn’t been about generating code for the sake of it. Instead, it’s been about applying AI across different types of ownership, complexity, and lifecycle stages of software. What’s emerged is a clearer picture: AI is most valuable not when it replaces development, but when it accelerates understanding, improves quality, and reduces friction.

Here’s how that has played out in practice.

1. Improving Code I Already Own

The easiest place to start was with code I had written myself—tools that are already in use and solving real problems.

Because I understood the intent and behaviour of these applications, AI became a powerful second pair of eyes. I used it to:

• Generate unit tests for areas that had little or no coverage
• Identify gaps in build and deployment pipelines
• Highlight potential security concerns
• Suggest refactoring opportunities for readability and maintainability

The result wasn’t dramatic rewrites. Instead, it was steady, compounding improvement:

• Higher confidence in changes due to better test coverage
• More reliable builds and deployments
• Reduced time spent on manual code reviews
• Cleaner, more maintainable codebases

This is where AI felt most immediately productive—augmenting existing knowledge rather than trying to replace it.

2. Making Sense of Legacy Systems

A more interesting challenge came from systems I hadn’t written—particularly those with limited documentation and where historical knowledge had faded over time.

Here, AI acted less like a coding assistant and more like a translation layer.

I used it to:

• Analyse unfamiliar code and explain intent
• Generate technical documentation from existing implementations
• Identify outdated dependencies and suggest upgrade paths
• Propose test strategies for systems that had none

What would typically take days of manual exploration could be accelerated significantly. More importantly, it reduced the risk of “guesswork engineering”—making changes without fully understanding the system.

Key outcomes included:

• Faster onboarding into legacy systems
• Improved stability through better understanding
• Reduced reliance on tribal knowledge
• A foundation for future modernisation

This was one of the most valuable use cases: turning unknown systems into known ones.

3. Tailoring the Tools I Use Every Day

Another unexpected benefit came from applying AI to open-source tools I use regularly.

Instead of working around limitations or minor frustrations, I was able to:

• Explore the codebase quickly
• Identify the root cause of issues
• Implement targeted fixes or enhancements

AI reduced the barrier to entry for modifying third-party code. Tasks that might previously have felt too time-consuming or complex became achievable in a short space of time.

The impact here was subtle but meaningful:

• Smoother day-to-day workflows
• Faster resolution of small but persistent issues
• Greater control over the tools I rely on

It shifted the mindset from “adapting to tools” to “adapting tools to fit the way I work.”

4. Reviving Older, Customer-Facing Solutions

Some of the most challenging scenarios involved older solutions that are still in use but no longer actively developed.

These tend to surface through support cases or escalations, often requiring rapid understanding and targeted fixes.

AI proved particularly useful in:

• Interpreting older coding patterns and structures
• Diagnosing issues from limited context
• Suggesting safe, minimal changes to resolve problems
• Documenting behaviour that had never been formally captured

This led to:

• Faster resolution times for complex issues
• Fewer repeat incidents
• Increased confidence when working in fragile codebases

Rather than treating these systems as untouchable, AI made them accessible again.

5. Enhancing Actively Maintained Solutions

Finally, I applied the same approaches to modern, actively maintained solutions—where expectations around quality, security, and consistency are much higher.

In this space, AI supported:

• Continuous improvement of test coverage
• Ongoing security reviews
• Documentation generation and updates
• Ensuring alignment with current platform standards

The key difference here is that AI becomes part of the development lifecycle, not just a one-off tool.

Benefits included:

• More consistent quality across releases
• Faster delivery of enhancements
• Improved confidence in production changes
• Better alignment with evolving standards

This is where AI starts to feel like a long-term capability rather than a short-term productivity boost.

What I’ve Learned

Across all of these scenarios, a few consistent themes have emerged.

1. AI Accelerates Understanding More Than It Replaces Thinking

The biggest gains came from reducing the time it takes to understand code—not from blindly generating it.

2. Context Still Matters

AI is most effective when you can validate its output. The better your understanding of the system, the more value you get.

3. Small Improvements Compound Quickly

Adding tests, improving pipelines, and tightening security might seem incremental, but together they significantly improve delivery confidence.

4. Legacy Work Is Where AI Shines

The less documented and more complex a system is, the more impact AI can have in making it accessible again.

5. It Changes What Feels “Worth Doing”

Tasks that previously felt too time-consuming—like fixing minor issues in third-party tools or documenting old systems—suddenly become viable.

Where This Goes Next

This is still early in the journey, but the direction is clear.

AI is not just a coding assistant—it’s becoming a core part of how we:

• Understand systems
• Maintain quality
• Reduce risk
• Deliver improvements faster

The next step is to move from individual use to repeatable patterns—embedding these approaches into team workflows, standards, and expectations.

Because the real value isn’t just in what AI can do—it’s in how consistently we can apply it.

From Curiosity to Capability: What My AI Learning Journey Has Actually Delivered

• Installs/Config for ERP systems including initial system design
• Technical training of customers in those ERP systems
• Technical management of escalated issues (across the world)
• Cross-team liason for high profile or highly escalated customers
• Coordination of international team of installations consultants
• Development of internal tooling for installs/ technical consulting
• Management of environments for wider team

From my recent posts it’s obvious which areas on that list have received the most focus over the last few months, notably the last two, which is where all the DevOps/Code posts are centred around. The reason so much focus has been on this, and I’ll add at this point a lot of it out of work hours, is because it’s something I enjoy, something I’ve been on the edge of before, and an area of technology that I personally believe we should all be at least aware of, and able to understand the basic principles of.

DevOps was a term coined many years before it became mainstream. Mike Loukides wrote a 20 page book called “What is DevOps” back in June 2012, which is published by the world renowned O’Reilly Media. (http://shop.oreilly.com/product/0636920026822.do) That’s some time before I came across the term, although it seems I was already aware of some of the practices that now come under that umbrella. Back then I was managing E-Commerce sites, writing PHP websites against MySQL databases and moving a very static, cumbersome “tin-factory” infrastructure over to more dynamic, sustainable growth-capable platform. With a little more time and knowledge at that time I would’ve potentially moved in different directions. I am now starting to close that circle a little from the other side.

For me, career development is crucial, I am more than happy to stay with one company, or in one role, but I will always push to make more of myself, learn new things, get involved with everything possible and break down any and all barriers. I don’t do this to benefit myself, I see it as an opprtunity for me to be a benefit to those around me, both customers and colleagues.

Outside of DevOps activities over the recent months I’ve also been working on my presentation skills, with opportunities to present to colleagues and customers about various technical topics, including System Adminstration, upcoming product changes, best practices etc. This is in part due to being given more free reign with my current role, while we work out what my future roles may or may not include, and that’s if any change at all! In the background, the day to role keeps me busy, planning installs, speaking to new customers about how to deploy, speaking to existing customers about upgrades or enhancements to their systems, all the fun stuff that keeps money in the bank and roofs over heads!

The next few months may get a little busy, well hopefully they will, and all the good stuff will be posted when the chances arise.

This and That

Fast forward on a little from my sysadmin days, and to the brave new world (for me) of ERP. My primary day job is planning, coordinating and performing installations of ERP software into all sorts of manufacturing and distribution companies. Some are small, many are large, so the nature of, the deployments can vary slightly. That’s generally the bit I’m good at; sizing and planning the system to meet size and expectations of the end users. What we found over the last 2 years is that whilst deployments vary slightly, there is a bulk of work that is virtually the same every time round, certainly in process if not inputs, however we found that amongst the team; time, accuracy and experience could vary, significantly in some cases. Therefore a colleague of mine, with vastly more years experience in product and process went to the efforts to write an automation tool, a set of PowerShell scripts and XML files used to automate the bulk of the installation process. Roll on a few months and instantly accuracy and time were improving, which in turn was improving everyone’s experience. Gone were the days of random (user) errors and here are the days of productivity and valid errors which have much, much more context!

So let’s get techy on this and roll on a little further in time; following a few changes, ownership of the tool is now with me. And with a potentially different future ahead, it may only be a short term thing (it may also be long term!), so with this in mind, I sought help of people who know what they are doing, exceptionally smart developers in this case. After a couple of remote session the following has occurred:

Task 1 – Get the code secured. We can’t have something this crucial to our process hiding on a random VM with no backups.

Solution –  Git based code repository, in this case Visual Studio Team Services (VSTS)

Task 2 – Get the additional features into the code, but fully tested before deploying.

Solution – Branch off. Currently running with 2 branches, one for immediate fixes/quick additions, and one for next revision which will do far more than just  installing (Shhhh it’s Top Secret)

Task 3 – Get the code tidied up, to some form of best practices etc.

Solution – VSTS Build running PowerShell scripts with Pester and PowerShell Script Analyzer to validate all PowerShell scripts against a set of generally accepted best practice rules.

Task 4 – Packaging. No one wants to manually build a zip file, upload it to a SharePoint site and email out a notification for every small fix that goes in

Solution  – NuGet and Chocolatey via a VSTS Package Feed.

Since this became my problem, three versions of the tooling have been released, packaging only got tested this week so isn’t the primary deployment method yet, but now we have it as a capability there will be many more versions, but that just wont matter as they will always have whatever is the latest in the master branch!

Ok so that all explains my random tweets from evenings and weekends over the last month or so, fortunately I’ve had some incredible guidance from some very skilled and friendly development colleagues. Without those guys, I wouldn’t be anywhere with all this other than a whole load of files and folders on one machine with no backups!

I’d also like to give back to the community a little, so I plan to have some scripts that I write for more generic tasks uploaded to a public facing Git at https://github.com/jaward916 further to that I have below added a list of all the bookmarks I’ve been building up, especially the ones around Tasks 3 and 4, which has been the key functionality I’ve explored and implemented in the last week.

I stress once again, I am not a developer, please do not laugh at my code, or my very basic explanations of the tools and processes, I am learning for fun, but developing to make everyone’s lives a little easier in my world!

Bookmarks for VSTS

• https://www.visualstudio.com/vso/ – Starting point for VSTS
• https://code.visualstudio.com/ – now my development tool of choice for writing and testing the scripts, lightweight and extendable/modular. Notepad++ is still my text editor of choice when analysing large logs or XML files i.e. One offs, but VS Code allows me to have workspaces, as well as sync automatically back to VSTS with an official plugin.
• https://docs.microsoft.com/en-us/vsts/git/use-ssh-keys-to-authenticate?view=vsts – For how to connect to your VSTS Repository once it’s setup
• https://docs.microsoft.com/en-us/vsts/git/tutorial/pulling?view=vsts&tabs=visual-studio – For moving code between branches
• https://github.com/pester/Pester/wiki/Pester – Pester project on GitHub for testing PowerShell code
• https://workingsysadmin.com/invoking-pester-and-psscriptanalyzer-tests-in-hosted-vsts/ – This one is the tutorial for invoking pester and making use of it with VSTS
• https://docs.microsoft.com/en-us/vsts/package/get-started-nuget?view=vsts – This one was crucial for the packaging element with NuGet
• https://chocolatey.org/install – how to install Choco, really simple, but guides help!
• https://roadtoalm.com/2017/05/02/using-vsts-package-management-as-a-private-chocolatey-gallery/ – This helped a lot with getting Chocolatey installed and the package deployed from my VSTS feed
• https://docs.microsoft.com/en-us/vsts/package/nuget/nuget-exe?view=vsts#add-a-feed-to-nuget-2 – you need this if you hit issues with Chocolatey not liking your feed version!

#Code