On an AI product, the thing you're short of is rarely engineering time. It's learning. How people actually ask, what they do with the answer, where the model falls over, which of your assumptions were wrong. Almost everything I'd tell the next PM comes back to getting that learning faster.
I've spent a good while leading an agentic chat product inside an accounting platform. These are the things I'd want someone to say to me on day one.
Get it in front of customers before it feels ready
The instinct, especially in a company with a reputation to protect, is to polish first. I'd resist it. A thin version that does one thing, put in front of a small cohort, teaches you more in a fortnight than a month of internal debate.
We ran this way on purpose: a thin end-to-end slice, small cohorts of real users in stages, a diary study alongside, and a lot of "scrappy now, platformise later". When we argued about which write action to prove first, the winner wasn't the most impressive one. It was the one that would surface the hard problems soonest.
The question I'd ask of any piece of work is not "is this good enough to ship?" but "what will we know in two weeks that we don't know today?"
You will always have tech debt, so choose it
This is the part that took me longest to accept. In most software, tech debt is something you work to pay down. In this field the ground under you moves too fast for that to be the whole story. Models change. SDKs change. The hosts that run your connector change. The approach that looked right in spring can look dated by autumn.
We hard-coded values in proofs of concept. We knew tool shapes would change when an SDK arrived. We planned an architecture migration partway through the life of the product. None of that was a failure of planning. Anything built to the current shape of the technology was always going to be rebuilt, so the sensible move was to build it thin, prove what you needed, and be willing to throw it away.
The skill is telling deliberate debt from accidental debt. Deliberate debt is a shortcut you chose, can name, and have a plan for. Accidental debt is what you drift into when nobody decided anything.
Get legal and safety inside the harness
By "harness" I mean the setup that runs your agent against a set of test cases and records everything it does. Most teams treat it as an engineering tool. I'd treat it as the room where the whole decision gets made.
If legal and safety only see your product at the end, you get a review. If they can sit inside the harness, you get a collaboration. Let them replay a trace. Let them read a judge's verdict and disagree with it. Let them write the cases that worry them, because the questions they're most nervous about are exactly the ones your golden set is probably thin on. A human has to define what "bad" looks like for the evals to mean anything, and the people who carry the risk are the best-placed humans to do it.
The same logic applies to the finished thing. Give legal and risk real time to use it hands on, not a slide deck about it. And start their clocks early, because they move at the pace of the business, not your sprint. A drawn-out flow they can react to gets you a better answer in a week than an abstract question gets in a month. Write decisions down, including who said what and what's still open.
Back the team's technical bets
The other half is trusting the people closest to the code. When we looked at a new agent framework, there was a real case against it. It was very new. It was built for long-running autonomous work when we needed tight, guardrailed answers. It paired naturally with a different tracing stack from the one we'd built around. Every one of those objections was fair.
What moved it forward was making the experiment small and honest. A few days. Scoped by the engineer who wanted to try it. One clear question: if we swap the engine in the middle, does our layered architecture still hold? We'd already designed the harness so that engine could be swapped, and an outside team ran the same experiment on their own prototype so we could compare notes. The team has since built real work on it, including human-in-the-loop flows that use its checkpointing.
I don't think my job there was to have the right answer about the framework. It was to make the bet cheap, say up front what would count as a result, and then get out of the way. The engineers had better instincts than I did, and a product leader who insists on being the one who decides will quietly teach a team to stop proposing things.
I'd add one rule: decide with the information you have, expect to revisit it, and protect the time to finish. At one point my team told me, politely, that too much energy had gone into going back and forth on design and they needed ring-fenced time to refine and test. They were right. Most of the quality in these products comes from testing against real behaviour, not from having picked the cleverest design.
Be loose about the code and strict about the evidence
There are a few things I wouldn't borrow against, and they're the ones that make your learning trustworthy.
The first is measurement. We had a coverage figure that moved the right way for weeks. It counted whether the router thought it could handle a question, not whether the person got a good answer. Both numbers were real and they told very different stories. If you're moving fast, your metrics are the only thing standing between you and fooling yourself, so be suspicious of any number that flatters the team.
The second is the gates around actions. When an assistant starts doing things on someone's behalf, the questions are where the write really happens, what the person is agreeing to, and how you prove it afterwards. You can prototype that quickly, and you should. What you shouldn't do is treat it as a polish step to add once the feature works.
I think of it as being cavalier with the implementation and careful with the evidence. The code will change. The record of what you tried and what you learned has to hold up.
Ask where the number came from
I write short documents with bullets, and I'm fussy about traceability. If a claim is going in front of senior people, I want to know where it came from. It sounds pedantic. In practice it's the cheapest quality control I know, especially when you're moving quickly.
An AI team produces a lot of confident-sounding numbers: accuracy, coverage, satisfaction, latency. Some measure something other than what their names suggest. A PM who routinely asks "what is this counting, and how would I check?" will catch things the dashboards never will. People also learn that your numbers hold up, which buys you a lot of trust.
If I had to leave one habit with whoever comes next, it would be that one.