A company where AI writes both code and content

In my environment today, AI really does write both code and content. Not as a conference demo. In production, every day, on things that have users and deadlines.

It's not magic. It's a tool with rules. And most people don't know the rules, so either it doesn't work for them or they trust it blindly. Both are wrong.

What it looks like in practice

I don't give AI steps. I give it a result. I say what should come out and how I'll know it's done. The agent makes a plan, touches files, runs commands, hits an error, and fixes itself. Meanwhile I hold the direction and check the output.

It works the same for content. I don't write the prompt "write an article". I give a role, context, task, format, and quality criteria. The difference between one sentence and five lines is the difference between generic filler and text that goes straight out.

An agent isn't a miracle, it's a tool with rules

Give an agent a big goal with no boundaries and it delivers something that looks done and isn't. Programmers say AI hides the toys under the bed. It looks tidy until you look under the bed.

So I scale the size of the goal by trust and risk. Low trust and a high cost of error mean a smaller goal and a shorter leash. High trust and low risk mean I let it run for a long time. It's not a binary choice between micromanagement and blind faith. It's calibration.

An honest gate, or it doesn't work

The most important thing in the whole setup isn't the model. It's a gate that can fail. For code that's a test, a linter, a real run. Not a second model that reads the code and says "looks good". That model never ran it.

I have a rule: it's done only when a real gate passes. Not when the model nods. Not when it looks good on screen. When a test that can say no passes.

A loop is only as honest as its gate. When a gate never fails, it isn't a gate, it's a rubber stamp.

Verification before trust

My cheap layer of checking is cross-model review. One model finishes, another with fresh context checks it and hunts for the weak spots the first one missed. It catches reasoning and missing requirements fast and cheap.

But for things that can actually break production, that isn't enough. There a real run has to come in. The depth of verification follows the cost of the error. Low risk gets handled by a review from a second model. High risk wants an actual run.

What to take from this

AI agents do real work today. Not because the model is smart, but because there's an environment around it: a clearly stated result, an honest gate, and verification proportional to risk.

Whoever builds this environment speeds up with AI. Whoever just opens a chat and hopes gets text that looks smart and leads nowhere. The difference isn't in the tool. It's in how you wire it in.