I’ve spent many hours inside an agentic harness. Over time I started noticing that the sessions that went well had three things in common, and the sessions that went badly were always missing at least one of them. I’d either set clear intent before the session started, or I hadn’t. I’d either reviewed the output at full bar, or I hadn’t. I’d either fed what I learned back into the harness, or I hadn’t.
The ownership bar doesn’t change because a model did the typing.
Once those patterns were clear, the framework to address them was obvious. Direct, Own, Tune.
The framework
Direct means setting clear intent before the agent does anything. What are you trying to produce. What are the constraints. What patterns should it follow. What should it absolutely not touch. If you don’t resolve ambiguity before the task starts, the agent “resolves” it for you.
Own means reviewing the output as if you wrote it yourself. Because you did. Your name is on it. Whether the agent produced code, copy, a user story, or an incident analysis, the ownership bar doesn’t change because a model did the typing.
Tune means taking what you learned and feeding it back into the system. The brief that worked becomes a template. The boundary the agent drifted past becomes an explicit constraint. The review checklist that caught the problem gets encoded so it runs the same way next time. Tuning is what turns a one-off win into a repeatable one.
Direction
Direction is where you set yourself up to understand your own vision. Before the agent does anything, you should be able to articulate what you’re trying to produce, what the constraints are, and where the boundaries are.
A PM turning a vague executive ask into a sprint-ready user story needs to know the audience, the acceptance criteria, and the scope before the session starts. “Write a user story for guest checkout. Audience is a returning shopper who abandoned cart at account creation. Acceptance criteria: complete purchase without an account, payment errors show inline, cart persists across sessions.” The output might still need adjustment, but the adjustment is refinement, not rework.
Ownership
The relief of handing over a hard problem to an agent is genuinely addictive. You get back something that looks complete, you skim it, you move on. The work is still yours to own.
Own is the structural answer to that instinct. Review the output at the same bar you’d apply to your own work.
For marketing copy, that means reading every word as if you wrote it. Does the headline actually communicate value, or is it just technically accurate. Is the tone consistent across channels, or did the agent shift register between the long-form and the short-form deliverables. Did it pull language from the product spec that would confuse a non-technical reader. Does it sound like something your team would produce, or does it sound like something an agent produced.
Tuning
Most of the time, once the work is done, people move on. The task shipped, the session’s over, on to the next thing. Tuning is the step that breaks that pattern, and it’s the one that pays the biggest dividends over time.
Without tuning, the same context gets re-explained every session. The architectural boundaries, the patterns to follow, the test commands. The agent drifts past the same boundary that was corrected the session before, because the correction lives in someone’s head. The tooling produces value, but the value doesn’t compound. Every session starts from roughly the same place.
Tuning is the step where you take what worked and encode it. The brief format that produced a clean user story on the first pass becomes a reusable skill. The architectural boundary the agent kept drifting past gets written into the context so the next session starts with that constraint already loaded. The review checklist that caught a problem becomes the standard checklist.
I built Runbook out of this same instinct. The agent kept inventing its own commands instead of using the ones that actually worked. So I stopped asking it to choose and gave it a deterministic tool that only does the right thing. That’s tuning. You take a failure mode, turn it into a constraint, and remove the opportunity for it to happen again.
Across roles
The mental model works the same way regardless of the function or the level of technical proficiency. For example:
I’ve written separately about how the rest of the business is hitting the same scaling wall that IT hit decades ago, and how the answer then was the same as the answer now: stop throwing bodies at the problem and start building systems that absorb the work. DOT is a mental model the rest of the business world can use to start pushing that mentality forward.
Getting real value out of AI takes discipline and intention. Clear direction produces better output. Thorough ownership keeps the bar high. Consistent tuning makes the harness sharper every cycle. That’s DOT.