Did the state change? A simple test for whether work actually happened

Someone walks into the meeting and says they worked on it all week. There is no document. There is no draft. There is nothing anyone can open, read, or act on. The meeting proceeds anyway. People nod. Someone asks a follow-up question as if partial progress has been banked somewhere. The conversation moves forward on a foundation that does not exist.

This happens constantly. It happens in status updates, in project check-ins, in one-on-ones where people report activity as if activity were the deliverable. Work has become increasingly invisible, which means the signals that stand in for work have become increasingly unreliable. Effort is visible. Output is not always visible. So effort gets reported, and effort gets received, and somewhere in that exchange the actual state of the work gets lost.

There is a clean rule that cuts through this. It does not require better communication norms or more rigorous project management. It requires one honest question: did the state change? Either something exists now that did not exist before, or it does not. Either someone downstream can use what was produced, or they cannot. That is the whole test. Everything else is commentary.

The rule sounds simple. The implications are not comfortable. Most professional environments have built elaborate social infrastructure around the idea that effort counts, that starting is meaningful, that intent matters. The rule does not care about any of that.

Effort without a state change is not partial progress. It is zero progress for everyone else in the system.

That is not a harsh framing. It is a precise one. When a piece of work is unfinished, it cannot be used. It cannot be reviewed in any meaningful way. It cannot be built on. The person who was supposed to receive it is in exactly the same position they were in before the week started. They have no new input. They cannot make a decision. They cannot move their own work forward. From a systems perspective, nothing happened.

The confusion here is that starting feels like something. It registers internally as movement. There is cognitive load, there is time spent, there is genuine effort. None of that is false. But effort is an internal state. The system does not update based on internal states. It updates based on artifacts, decisions, and deliverables that exist in a form others can receive and act on.

Starting is not a unit of work. It is a precondition for work. The unit of work is the thing that changes the state for someone else.

This matters more now because knowledge work has made effort almost entirely invisible to anyone outside the person doing it. In a physical environment, partial progress is often legible. You can see the foundation poured, the wall framed, the wiring run. In knowledge work, the internal experience of effort and the external reality of output are completely decoupled. You can spend a week thinking hard about a problem and produce nothing anyone else can touch. That week registers to you as significant. It registers to the system as silence.

Reporting effort as progress misrepresents the actual state of the system to everyone who depends on the output.

This is where the stakes get serious. It is not just that nothing happened. It is that people downstream made plans based on the assumption that something was happening. Decisions got deferred. Work got scheduled. Dependencies got arranged around a deliverable that does not exist. When the deadline arrives and there is nothing to show, the damage is not just the missing output. It is everything that was built on top of the false assumption.

The person reporting effort usually does not intend to mislead anyone. That matters. The intent is usually to signal engagement, to show that the work is being taken seriously, to avoid the discomfort of reporting nothing. The intent is often genuinely good. But intent does not change the state of the system. The downstream team does not get to use good intent. They need the artifact.

This is why it functions like dishonesty even when it is not dishonest in any deliberate sense. The representation being made is that progress is occurring, that something is nearly done, that the situation is better than it was. If none of those things are true in any way that the system can register, then the representation is inaccurate regardless of the intention behind it.

The pattern shows up in specific, recognizable forms.

A half-written document gets shared as “a draft.” The word draft implies something reviewable, something with enough substance to generate useful feedback. A document that is forty percent complete and structurally incomplete is not a draft in any functional sense. Sharing it as one creates the impression of progress while actually creating work for the recipient, who now has to figure out what is real and what is placeholder. The state has not changed in a useful direction. It may have changed in a negative one.

A verbal agreement gets reached in a meeting. Everyone leaves with the same understanding. Nothing gets written down. A week later, the understanding has diverged in three directions, and no one can reconstruct what was actually decided because there is no artifact. The agreement existed as a shared mental state for approximately forty-five minutes. It was never real in any form the system could use. Verbal agreements without recorded artifacts are not decisions. They are conversations about decisions.

“I started on it” arrives as a status update. This is the clearest case. Starting is not a reportable unit. The only honest status update is either “here it is” or “I don’t have it yet.” Everything in between is noise that the recipient has to interpret, discount, and work around. When someone reports that they started, the recipient has to decide what that means, how far along it is, whether to press for more, whether to adjust the schedule. None of that interpretive work should be necessary. The status either represents a state change or it does not.

The operating rule is simple enough to apply in real time: the state either changed or it did not.

An artifact exists or it does not. A decision is recorded or it is not. A deliverable can be received and acted on or it cannot. These are binary conditions. There is no partial credit in the state of the system. The document either exists in a form someone can use or it does not. The decision either has a record that can be referenced or it does not. The work either moved something forward for someone else or it did not.

This rule is not about perfectionism. A rough draft that exists is infinitely more useful than a polished draft that does not. A decision recorded in three bullet points in an email is infinitely more durable than a consensus reached in a room and never written down. The standard is not quality. The standard is existence. Does something exist now that did not exist before, in a form that changes the state for at least one other person?

The reason this rule matters at the organizational level is that accountability cannot attach to effort. Accountability requires a moment of state change, a point in time where something either happened or it did not. Without that, accountability becomes diffuse, contested, and ultimately meaningless. Everyone worked hard. Everyone had good reasons. No one can point to the moment where the failure occurred because no one agreed on what completion looked like.

When you define completion as a state change, the failure becomes locatable. The state either changed on Tuesday or it did not. If it did not, the accountability lives with the person responsible for that change. Not because they are a bad person. Not because their effort was worthless. Because they are the one who owns the last mile.

The last mile is the only mile that changes anything.

Everything before it is preparation. The thinking, the research, the drafting, the iteration, the internal deliberation, all of it is necessary and none of it is the work in the sense that matters to anyone else. The work, in the sense that matters, is the moment the state changes. The moment the document lands in someone’s inbox. The moment the decision gets recorded. The moment the deliverable becomes something another person can receive and use.

This is not a diminishment of the work that comes before. It is an accurate description of where accountability lives. You can do everything right for ninety-five percent of the process and still leave the system in the same state it was in before you started. The last mile is where the work becomes real for everyone else.

Last month we rebuilt one of our products around this rule, and it taught me the rule works even better as a schema than as a speech. Authexis used to track content with a pile of status columns, and the pile could lie. A piece could sit at stage=idea, status=approved, a sentence with no meaning that the database was happy to store. The rebuild replaced all of it with a directed graph. A piece is a token sitting on one node. It has exactly two verbs: move to an adjacent node, or edit a field. Where the piece is, who owns it, what happens next: all derived from the node, never asserted by anyone. Seven separate code paths for pushing work forward collapsed into one adjacency-checked move.

The point is not the engineering. The point is that the system now enforces this essay. A piece either moved to a new node or it did not. There is no column for effort, no field for “started,” no way to record that somebody worked on it all week. The database can only register state changes, so state changes are the only thing anyone can claim in the meeting.

Accountability attaches to that moment because that is the only moment that counts for the system. Not the effort. Not the intent. Not the week of hard work that preceded it. The state change. That is the deliverable. That is the unit. That is where the question of whether something happened gets answered.