Frank
Here’s the answer upfront: using Claude or any other AI to help you write a script doesn’t make the result less yours. What it does is collapse the distance between the problem you can clearly describe and the code you couldn’t quite remember how to write. That’s not a shortcut. That’s just a better tool.
Now let me explain how I actually got there, because my path was not graceful.
The Problem That Started This
About six months ago I needed to pull a report from Active Directory. Specific stuff: all user accounts where the last logon was over ninety days ago, the account was still enabled, and the UPN didn’t match a specific domain suffix. Three conditions. Filtered output. Export to CSV so someone who’s allergic to PowerShell could open it in Excel.
I know Active Directory. I know PowerShell. I’ve written hundreds of these queries over the years. But I sat there for longer than I want to admit trying to remember the exact syntax for -Filter vs Get-ADUser with -LDAPFilter, and whether LastLogonDate vs LastLogon was the one that actually replicated across domain controllers. Because those two things are not the same and one of them will lie to you.
My brain doesn’t unspool information in a straight line. It never has. I can tell you everything about why LastLogon doesn’t replicate and LastLogonDate does, but the second I need to recall the exact property name under deadline pressure, something short-circuits.
So I described the problem to Claude in plain English. Not “write me a script.” I explained what I was looking at, what I needed to filter on, and what the output needed to look like. Same way I’d explain it to a coworker.
What came back was close but not perfect. LastLogonDate was right. The UPN filter logic needed an adjustment. I told it what was wrong, it revised it, I tested it in our dev environment, caught one more edge case, fixed it. Done.
Total time: maybe twenty-five minutes. Versus however long I would’ve spent bouncing between five browser tabs and a Microsoft docs page that hasn’t been updated since 2019.
What the “That’s Cheating” Crowd Gets Wrong
The argument goes like this: if you can’t write it from scratch, you don’t understand it.
That argument might hold water if the goal were to demonstrate mastery for its own sake. But the goal was to get a clean report to the security team by end of day so they could start working through stale accounts before an audit. The goal was the output. Not a performance of how I got there.
I understood every line of what Claude generated. I knew where it was wrong and why. I fixed it. If I’d had no idea what I was looking at, I would’ve had no way to catch that the filter logic wasn’t handling disabled accounts the way I expected. Understanding is what let me use the tool correctly. The tool didn’t replace the understanding. It just handled the part where I couldn’t remember whether you use -and or -And in a filter string when your brain is fried at 6 PM on a Thursday.
The Rubber Duck Has Always Been the Point
There’s an old debugging technique called rubber duck debugging. You explain your code, line by line, to a rubber duck sitting on your desk. The act of explaining it out loud forces your brain to slow down, and about halfway through you usually find the bug yourself. The duck never said a word. It didn’t need to.
AI-assisted scripting is that, except the duck occasionally gives you a working draft.
The part of my brain that thinks best is the part doing the explaining, the describing, the framing of what I actually need. I figured that out a long time ago when I started writing things down just to get them organized in my own head. Talking to Claude is the same mechanism, just with actual output on the other end. My thoughts aren’t linear. My code doesn’t have to be either, as long as the result runs clean.
The Part Nobody Talks About
Here’s the thing that actually matters and that I don’t hear discussed: AI-assisted scripting is forcing me to get better at articulating problems precisely.
Vague input produces vague code. If I can’t tell Claude exactly what I need, I’ll get something that’s close but wrong, and debugging a script someone else wrote based on your own fuzzy instructions is its own special kind of misery. So I’ve gotten sharper at defining the problem before I ever type anything. That skill transfers directly to everything else I do.
The rubber duck got smarter. So did I.
