Day one is the peak
I've spent significant number of years building B2B software and running a business unit, which means I've lived on both sides of this category: the roadmap rooms where products like these get designed, and the operating seat where you run a team on top of them. Both seats taught me the same uncomfortable thing, and it took me years to say it plainly. The software wasn't underperforming. It was performing exactly as designed, and the design was the problem.
How a field is born
Start with how software actually gets made, because the pattern holds whether the product manages customers, projects, or infrastructure. A team designs a data model. The data model needs feeding. And since software can't perceive anything on its own, the user gets drafted to do its perceiving for it. Every required field marks something the product needs to know and has no way to learn by itself. A form is how blind software asks you to describe the world to it.
Watch how an individual field comes to exist and the whole economy of the thing becomes visible. Someone senior needs a report. The report needs a field. The field becomes required, because an optional field produces an unreliable report. From that day forward, every user pays a few seconds and a little attention on every record, forever, so that one report renders correctly. The person who requested the field never feels this cost. And here's the detail I'd ask you to sit with: in all my years in roadmap rooms, I have never once seen a meeting called to delete a field. Fields accrete like sediment. Ten years into any serious deployment, half the form is a fossil record of reports nobody runs anymore, and the users are still paying for all of it.
Nobody calls it that in a roadmap meeting. It gets called structure. Validation rules and mandatory fields ship as data quality features, and when users grudgingly comply, the dashboard calls it adoption. I don't say this as an accusation. When your product can't see, making the user type more is the only lever you have, and for decades the whole industry pulled it in good faith.
The spreadsheet under the desk
Now the operator's seat, because running a business unit teaches you something the builder's seat politely ignores. Every team I've ever run or watched closely kept a second system: the spreadsheet, the doc, the channel where the real state of the business lived. The official system got fed on deadline, the night before the review. The shadow system got fed voluntarily, in real time, because it actually helped the people doing the work. If you want to know what your team thinks of your official tooling, don't read the adoption dashboard. Look for the spreadsheet under the desk. Its existence is the most honest product review you'll ever get.
There's a reason the shadow system wins, and it compounds over time. An enterprise system is most accurate on the day it goes live. The fields match the business, the stages match the process, the dashboards reflect something true, because a roomful of people just spent months making it so. Then the business moves and the configuration doesn't. New motion, new segment, new pricing, and reality drifts away from the boxes a little more each quarter, until the system is a portrait of the company you were at implementation. I've sat in weekly reviews making real decisions on numbers I knew were secondhand, and managed the representation of work instead of the work. Software built on asking doesn't just burden its users. It peaks at go-live and ages from there.
You can't bolt on perception
The last few years, the industry's answer has been to attach AI to these products, and as a product person I think the failure is architectural, not a matter of effort. In enterprise software, the data model is the product. Everything else is paint. A form-centric data model assumes its facts arrive typed by a human, so an assistant built on top of it inherits that assumption whole. You get faster typing, suggested values, a chat window over the same rows. The questions don't go away, because the architecture is the question. Retrofitting perception onto a product designed around asking is like adding a camera to a filing cabinet. The cabinet doesn't start seeing. It just gets a camera.
What changed is that software stopped being blind, and this time it's real perception, not a plugin. It can sit in the meeting, follow the email thread, catch the follow-up everyone forgot. For a product person, this inverts the central question of the entire category. For as long as I've been building, we asked: how do we get people to tell the system what happened? The question I finally get to build against is better: given that the system knows what happened, what should it do about it?
Three decisions
We've been building an answer for a while now, and three decisions shaped it more than any feature.
The first is who's in charge. Think Tesla Autopilot rather than Waymo: the system watches everything, proposes constantly, and does nothing without your hand on the wheel. This isn't timidity, it's arithmetic. One wrong autonomous email to a customer costs you more trust than a thousand good drafts earn back. An AI that acts on your customers without your judgment isn't a teammate. It's a liability with your signature on it. So permission is a first-class part of the product, and autonomy is something the system earns from you in increments, not something you're opted into.
The second is the interface. Structure was never the enemy; demanding it at the point of entry was. When software can understand a conversation, the conversation becomes the interface, and structure becomes something the system derives from what happened rather than a toll you pay before you're allowed to continue. The pipeline view survives. The lists and reports survive. They stop being things you feed and become windows you look through, and for the first time the report and the reality can actually agree, because they're drawn from the same source.
The third is the arc. When a system learns the business from what actually happens inside it, the go-live peak flips. Day one is the worst it will ever be. The memory of your customers compounds, the understanding gets sharper every week, and the portrait stays current because it keeps being painted. Even the configuration stops fossilizing, because a system that can read the business can notice when the business has outgrown its own settings. That's the opposite of every enterprise rollout I've lived through, and it's the part of this that satisfies me most as a builder.
The fair question
Software that perceives the work raises an honest concern: is this surveillance with better branding? It's the right question, and the answer lives in who benefits. The old design watched you so someone above you could feel informed, and gave you homework as the price. Perception pointed the other way works for the person actually in the deal: it preps your call, catches your dropped thread, defends your follow-up while you sleep. Same capability, opposite beneficiary. Whether people embrace a tool has always come down to that one variable, and every builder knows it.
None of this asks anyone to become a different person on a different workday. That was a design constraint from the start, not an afterthought. Products people love don't demand new behavior. They remove old chores.
I've spent my career watching software ask people to describe their work to it, and a good stretch of that career running teams who paid the tax. Building the product that stops asking has been the most fun I've had as a builder. In a few weeks, I'll show it to you.



