TRAVIS J. MACDONALD / WRITING

AI Didn't Replace My Work. It Moved the Work Up a Level.

AI makes generation faster while shifting the work toward framing, research, supervision, judgment, and verification.

← All Writing

AI & TECHNOLOGY

A designer redirects a path through an architectural maze above an automated model-building workshop.

I have had to fight AI constantly.

That probably sounds like an odd opening for an article about how useful it is. But both things are true. AI helps me get more work done, and a surprising amount of that work involves arguing with the tool that is supposed to be helping.

“That isn't possible.”

According to what? The platform? The dependency? The approach you picked thirty seconds ago? Or the limits of the answer you happened to generate?

There is a considerable difference between a hard constraint and a collaborator who has run out of ideas. AI can deliver both in exactly the same confident voice.

Learning to hear the difference matters more than learning a magical arrangement of prompt words.

The first answer contains a frame

When you ask for a solution, you also get a proposed definition of the problem. Sometimes that definition is useful. Sometimes it quietly contains assumptions that make the solution impossible before anyone has investigated much of anything.

We must use this library. The server must do this work. The input must remain in this format. The operation must happen in real time. The feature must live inside this particular component.

Must it?

Those assumptions might be requirements. They might also be leftovers from the most obvious approach. If you do not separate the two, you can spend an afternoon negotiating with a wall that nobody needed to build.

Refusing the first frame means asking where the actual limit is. Is the desired outcome impossible, or does the selected method fail to produce it? Is the problem in the product, the implementation, or the description we gave the tool?

It means being willing to say, “Fine. That route fails. What happens if we move this part over here?”

This is ordinary engineering judgment. AI makes it newly conspicuous because you can now receive a polished explanation of the wrong problem at extraordinary speed.

“Can't” needs an address

Suppose a particular service cannot perform an operation on a document. That is useful information about the service. It does not automatically establish a universal fact about documents.

Could another library handle it? Could we transform the input first? Could we extract the necessary information and rebuild the output? Could a local process do the expensive work before the file reaches the service?

Each alternative creates tradeoffs. A conversion might lose formatting. A local process might complicate distribution. A browser implementation might struggle with large inputs or expose information that should remain elsewhere. Moving work is a design decision, not a disappearing act.

But now there is something concrete to evaluate.

“This API does not expose that operation” is a constraint with an address. “That cannot be done” is often an invitation to ask for one.

Sometimes the address is the laws of physics, an unavoidable security boundary, or an incompatibility with the actual requirements. Then the answer really is no. Good judgment includes accepting a demonstrated limit. Endless insistence can waste as much time as premature surrender.

The useful habit is to make the boundary explicit before accepting it.

Research is part of the work

One of the most productive questions you can ask an AI is also one of the least glamorous:

“Did you actually look?”

Did it inspect the documentation? Did it check another source? Did it find an existing implementation? Did it verify that the feature is absent, or merely fail to remember where it lives?

There may already be a project that solves most of the problem. There may be a smaller dependency that does the one thing you need. There may be a useful technique in a project you would never adopt wholesale.

Looking for open-source options is practical research. Looking for MIT-licensed options can be a sensible starting preference when you want a permissive component. But a repository description is not a licence review, and a familiar licence label is not an assessment of whether the software belongs in your product.

Read the actual licence. Check the relevant dependencies and assets. Understand what you need to preserve or provide. Then evaluate maintenance, compatibility, security, and fit. A component can be available to use and still be a terrible choice.

The discovery step expands the possible solutions. The evaluation step stops discovery from becoming a shopping spree with a compiler attached.

AI can help with both. It still needs supervision during both.

The work moved

If a tool drafts a function, I spend less time typing the function. That is a real gain.

But somebody still has to decide whether the function belongs there, whether its assumptions match the surrounding system, whether it fails safely, and whether the apparent solution creates a larger problem somewhere else.

Faster production does not remove those questions. It can multiply them.

You can generate more code than you can responsibly absorb. You can produce five plausible architectures before lunch, all of them solving slightly different requirements. You can get a beautiful explanation that collapses the moment it meets the actual data.

The bottleneck moves toward judgment: defining the problem, establishing boundaries, selecting tradeoffs, checking evidence, and integrating the result.

This is why “AI wrote it” says so little about the amount of work involved. Typing is one visible activity. Deciding what should be typed, noticing what is wrong, and getting the pieces to behave together are also work.

The tool accelerates some of the easiest parts to count. The remaining work is often harder to see.

Hands compare a machine-produced component against a reference using a caliper and a test fixture.

Supervision needs a method

Arguing with AI is useful when the argument produces better evidence or a better design. Otherwise it is just two sources of stubbornness sharing a text box.

I want a disagreement to resolve into a testable question. What claim are we making? What would support it? What would disprove it? What is the smallest useful experiment?

If the claim is that a library cannot do something, inspect its documented interface or try a focused example. If the claim is that an approach preserves data, compare the result against the original. If the claim is that the feature works, exercise the behaviour the user actually needs.

Verification should match the claim. A successful build establishes something useful about the build. It does not establish that a workflow is usable, that a conversion preserved every detail, or that a feature behaves properly under the conditions that matter.

The point is to reduce uncertainty without building an entire second project devoted to congratulating the first one.

Research, experiments, review, and restraint all belong in the same workflow. So does stopping an approach when the evidence says it is wrong.

Leverage still needs a person holding the other end

I do not need AI to be an oracle. I need it to be useful.

Useful means it can help me explore alternatives, inspect a system, draft an implementation, or expose a gap in my own reasoning. Useful also means I can challenge it, correct it, and ask it to substantiate what it just told me.

The person directing that work still matters. Their knowledge helps them spot a false constraint. Their experience helps them anticipate a failure. Their judgment determines which promising idea is worth pursuing and which clever workaround should be left alone.

That is the part a demo of instant code generation can leave out. The visible output arrives quickly. The responsibility for understanding it stays put.

AI has given me more reach. It has also given me more things to supervise.

And when it says the problem cannot be solved, I want to know which problem it thinks we are solving.