The Top 10 Things I'm Actually Using AI For

A while back I wrote about ReviewPR, an Azure Function that uses AI to review Azure DevOps pull requests. That was one specific use case, but over the last year AI has become part of my day-to-day workflow in a lot of other ways.

For context, we run Optimizely CMS 12 and Commerce Connect 14 on DXP for a national homebuilder. It's a large platform with a lot of moving parts, years of history, and a relatively small team responsible for keeping everything running.

The biggest thing that changed for me is that I stopped thinking of AI as a coding tool. The real value has been giving it access to the systems I already use every day, then letting it help connect information across them. Logs, telemetry, deployments, databases, source code, configuration, and documentation all tell part of the story. Having something that can look across all of them at once has saved me a surprising amount of time.

Here are the areas where I've gotten the most value from it.

1. Troubleshooting Production Issues

This is the one that changed how I work.

Most production incidents aren't caused by a single obvious failure. They show up as symptoms scattered across several systems, and a lot of the effort goes into figuring out which signals actually matter.

One recurring pattern has been discovering that the original assumption was wrong. Problems that looked like database issues turned out to be networking issues. Stability problems ended up being scaling rules watching the wrong metric. Intermittent exceptions came back to application design problems that had been hiding for months. Looking at telemetry, deployments, infrastructure metrics, and source code together tends to surface connections that are easy to miss when you're investigating one system at a time.

Just as importantly, it's been useful for ruling things out. Finding out a theory is wrong in an hour is often more valuable than finding the right answer after three days.

2. Answering the Questions Nobody Has Time For

Every long-running Optimizely implementation develops a backlog of questions that never quite make it onto a sprint.

Which scheduled jobs are still needed? Which old integrations can be removed? Are there migrations that never completed correctly? How much data is sitting around because nobody ever cleaned it up?

These are all answerable questions, but they're usually more tedious than difficult. AI has been particularly useful for this kind of investigative work because it can sift through the details much faster than I can manually.

3. Building Small Projects That Cross Too Many Boundaries

Some of my favorite uses have been side projects that touch several different technologies at once.

Usually these aren't difficult projects. They just require learning a new API, figuring out an authentication model, understanding an unfamiliar library, and wiring everything together. That's often enough friction to keep a good idea from ever getting finished.

Having AI help bridge those gaps has made it much easier to take an idea from concept to something working without spending days context-switching between documentation sites.

4. Arguing With My Own Code

I've gotten into the habit of asking for a deliberately skeptical review before opening a pull request.

Not "does this look okay?" but "explain why this is wrong."

That tends to produce much better feedback. It's caught fixes that only suppressed warnings, tests that weren't actually validating behavior, and assumptions that looked safe until somebody challenged them. Even when I disagree with the feedback, forcing myself to defend the implementation usually improves the final result.

5. Writing Better Tests

This is one area where I've learned to be careful.

Left alone, AI tends to write tests around implementation details rather than behavior. Those tests often pass, but they don't necessarily prove anything valuable.

The best results have come from treating it like a partner in test design rather than a test generator. I want help identifying scenarios, edge cases, and requirements. The actual test is much less important than proving the behavior we're trying to protect.

6. Making Sense of Telemetry

Modern systems generate more telemetry than most developers can realistically consume.

One thing AI does well is help summarize what changed between two periods of time and identify where an investigation should start. Sometimes the answer is obvious after the fact, but getting to that point can require digging through thousands of events, metrics, and traces.

The biggest value isn't necessarily the answer itself. It's reducing the amount of time spent looking in the wrong place.

7. Finding the Bugs Nobody Sees

Some problems are obvious once they're found and almost invisible before that.

I've seen issues caused by a single unexpected character, subtle data inconsistencies, and small assumptions that quietly affected behavior without ever generating an obvious failure.

These are the kinds of things humans can find, but they're also the kinds of things we tend to overlook because we're focused on larger problems. AI is surprisingly good at noticing details that don't stand out during normal troubleshooting.

8. Capturing Institutional Knowledge

Every team has information that exists mostly in people's heads.

Environment-specific quirks, deployment lessons, platform limitations, and the odd exceptions that nobody remembers until something breaks.

I've started being much more intentional about documenting those lessons. AI has been useful for organizing and retrieving that information, especially when it spans years of projects and multiple systems.

9. Hardware Troubleshooting

The same approach works surprisingly well outside software development.

Most hardware troubleshooting comes down to collecting evidence. Event logs, diagnostics, performance data, firmware versions, and error messages all provide clues, but pulling them together takes time.

Being able to feed in the evidence and get a structured analysis has made the process significantly faster.

10. Home Networking and Security

I've also used AI extensively for home networking and security projects.

The biggest value hasn't been creating configurations. It's been reviewing them. Understanding what a rule actually allows, identifying unnecessary exposure, and validating assumptions turns out to be just as useful at home as it is in production systems.

One lesson that carries across both worlds is that asking "what could this reach?" is often more useful than asking "is this secure?"

A Few Things to Watch

AI gets things wrong. Regularly.

The failure mode isn't that it doesn't know the answer. The failure mode is that it gives a clean, confident explanation that sounds reasonable and happens to be completely wrong.

That's why I always want to see the underlying evidence. The logs, the query, the deployment, the code, or whatever data led to the conclusion.

I've also found that context matters far more than prompts. The more access it has to the relevant information, the more useful it becomes. A model that can read logs, telemetry, source code, and configuration is a very different tool from one that can only answer questions in a chat window.

Conclusion

If I had to summarize where AI has helped me most, it comes down to three things:

• Investigating problems faster.
• Connecting information across systems.
• Challenging assumptions before I spend time acting on them.

It hasn't replaced experience, judgment, or critical thinking.

Mostly, it's removed a lot of the manual digging that used to sit between noticing a problem and understanding it.