How I think a team should stay on the same page

2026-10-08


Any group of people working toward a goal has to solve the same problem: keeping everyone on the same page about what the group is doing, who is doing it, and where it stands. Most organizations handle it with meetings, messages and memory, and spend a large share of their time and energy doing so. ORGCORD is a framework for handling it better. It starts from first principles, with why organizations exist and why they struggle, and works down to the day-to-day practice of running work in a project management tool. The aim is a team that spends less time getting on the same page and more time doing the right work: more focus, more output, and an organization that can grow without drowning in coordination. This writing explains what a coordination system is (the tools, rules and habits a group uses to stay on the same page) and argues that its job is to keep five things in sync across a team: the goal, who owns what, what matters most, where things stand, and what depends on what.

None of this comes from having mastered it. Our team is still far from using these tools perfectly, and there's a lot left to learn and build. But I do spend a lot of time thinking about the problem. I'm an analytical freak: I've tried many task managers, and built custom ones too. Through 2025 and 2026, in the companies I help run, I've watched these ideas work and fail, struggled to get them implemented, and learned how differently people approach organizing their work. The mistakes taught us the most. This writing is my perspective from that experience, written from first principles so that it can be useful beyond our own teams.

How this was written. The ideas grew out of our experience, and with many conversations with the people credited below. I developed them in notes and voice memos, and pressure-tested them in conversation with AI. AI also helped me research the background, organize the material and turn spoken notes into written prose. I reviewed and edited every chapter.

A note on tools and words. There are many project management tools, and many good ways to organize work. The principles here apply to any of them. The tool we use is called Linear, and I'm a big fan of it: it has worked very well for us, and a lot of its published thinking shaped mine. Throughout this writing I use Linear's names for things (initiatives, projects, milestones, cycles, triage), with one exception. What Linear calls an "issue," this writing calls a task, because "issue" can sound like a problem. In the chapters about running the tool, I write "task (issue)" so the two words stay connected.


It reads best on the site at org-cord.com, with the figures and contents laid out properly. You can also keep reading the whole thing right here. The PDF and the cheat sheet are on the site too.


Contributors

This writing is from my perspective, but the thinking behind it isn't. It was shaped by the people I build with, through our experiments, our mistakes and our wins, and especially through the ways we see work differently.


Part One. The problem

Part One makes the case for why coordination matters: why organizations are worth having, why being organized matters even for one person, and why keeping a group in sync gets harder with every person added.

1. Why organizations exist

Before building a system for how a team coordinates, it helps to be clear about why being part of an organization is worth it at all. If someone doesn't believe it is, nothing built on top of that belief (system, principles, culture) will matter.

Organizations make a different kind of output possible. Here are seven advantages I can think of that organizations have over individuals:

  1. Specialization. One person building alone would need to be world-class at everything: development, sales, finance and the rest. A specialized group produces more, and better.
  2. Parallel execution. A team of five has five times the hours in a day of a team of one. The real power is that things happen in parallel instead of one at a time.
  3. Cognitive diversity. A single brain has blind spots. Several brains together have far fewer. Different perspectives strengthen the best ideas and knock out the worst ones.
  4. Resilience. An individual is a single point of failure. A group spreads the risk and is "harder to kill."
  5. Continuity. A person lives one lifetime. An organization can outlive its founders and keep going across generations.
  6. Accountability. Your work affects other people and a larger mission. That visibility and interdependence creates positive pressure.
  7. Scale of ambition. For all these reasons, a team raises the ceiling on what feels possible. People think bigger when others can help them get there.

None of these advantages are automatic. Each depends on people being able to work together well, and working together well takes structure. Building that structure is the purpose of this writing.

Organizations also have a dark side: bureaucracy, politics, groupthink, and room for people to hide. Where all of that comes from is a big question, and one I may come back to in future writing. I suspect part of it is the problem this writing is about: people can't keep what's in their heads in sync efficiently or effectively.

2. Why being organized matters

Before looking at a team, start with one person.

I don't believe anyone works better unorganized than organized, creative people included. Being organized just looks different for different people. Some plan out everything they'll do in a day. Others write down the two topics they're working on for the week. The right level of detail depends on the work and the person. Someone juggling several projects at once, with other people waiting on each of them, needs a detailed plan to keep the threads straight. Someone deep in a single creative project may need little more than a clear starting point and a finish line. Both have an outline, and everyone needs one, because everyone needs focus and clarity.

The reason comes down to bandwidth. Research on working memory suggests people can hold only a handful of things in mind at once: about four, in one well-known estimate from the psychologist Nelson Cowan. Unfinished tasks also tend to keep pulling at attention until they're done or planned. In 2011, the psychologists E.J. Masicampo and Roy Baumeister found that making a specific plan for an unfinished goal reduced how much it intruded on people's thinking. To focus on the work in front of you, everything else has to live somewhere outside your head. An external system, ideally a shared piece of software, is the most reliable way I know to free that bandwidth.

It's easy to see why people resist this. Being unorganized feels good in the moment. Jumping from idea to idea and following wherever the energy goes is fun, and every new idea brings a small hit of excitement. Ideation matters, and a good system leaves room for it. A whole working style built only around that feeling is hard to sustain, though, especially once other people depend on you. A system is what lets someone chase a new idea without losing the one they were in the middle of.

Now extend this from one person to a team. A brilliant individual working alone can live in total "chaos," because no one else ever has to find anything in it. To them it may not be chaos at all: there may be a method to the madness. The trouble starts when other people depend on that work, because they can't see the method, only the mess. There are better and worse ways to organize your own head, but once work is shared, the way it's organized has to make sense to everyone who depends on it.

3. The mental-state problem

Mental state, as I use the term in this writing, is what a person knows, understands and assumes at a given moment: what they think the goal is, what the priorities are, who is working on what, what "done" looks like, and what matters most right now.

Every person on a team carries their own mental state, and nobody else can see it. That is the root reason groups struggle to accomplish things together. There's no automatic way for people to share what's in their heads, so each person works from their own version of the picture.

Figure 1. Three people on the same team, working from three different versions of the same plan. None of them can see the others' version.

If everyone on a team knew exactly what everyone else knew, understood the same priorities, saw the same problems and was aware of every decision being made, the team wouldn't need to track work, send status updates or hold most of its meetings. People don't work that way. Each person has their own perspective, their own ideas and their own understanding of what's going on at any given time. They talk to different people, think differently and interpret things differently. Two people can walk out of the same conversation with completely different understandings of what was said, and neither of them knows it. They both believe they're on the same page, and they won't find out otherwise until the gap shows up in the work.

Sharing mental state doesn't mean everyone thinking the same way. Different perspectives and disagreement are an asset: they're the cognitive diversity that makes organizations powerful in the first place. What needs to be shared is the conclusion. After the discussion, the debate and the disagreement, everyone should share one understanding of what we're doing, why, and who is responsible for what. The thinking that got us there can stay varied. Where we landed has to be the same for everyone.

Agreeing on the plan is only the first half. As the plan moves forward, things change: work finishes, priorities shift, new problems appear, someone changes their mind. Staying on the same page while the plan progresses is arguably the harder part.

Meetings seem to be one of the most common ways people handle this, and they work. They put people in the same room to share updates, talk through problems and make decisions, and that has real value. They're also expensive. Four people in a one-hour meeting is four hours of output. And meetings can feed a loop: people are confused, so they meet; meeting leaves less time to do the work; the work falls behind and people are confused again, so they meet again.

4. Why the problem grows with every person

A person working alone has no coordination cost with anyone else. Everything they know is already in one head, so there's nobody to keep in sync. Add a second person, and there are now two mental states that can drift apart, with one line of communication between them that has to be kept current. This isn't only a big-company problem: even two or three people working closely together pay this cost, from the second person on.

Each line of communication is a pair of people who need to keep each other up to date. Not every pair needs one. A designer and a bookkeeper may rarely need to talk about their work at all. The lines that matter are between people whose work depends on each other.

The worst case is a group where everyone's work touches everyone else's. Then every pair needs a line, and the number of lines grows much faster than the number of people:

In general, a group of n people has n(n − 1)/2 possible pairs.

Most organizations cut this down with structure. Split 20 people into four teams of five, and have only the four team leads keep in sync across teams. Each team has 10 lines inside it, and the leads have 6 lines between them: 46 lines instead of 190. That's a real improvement, and it's one of the problems teams and team leads help solve. The lines still multiply as people are added, though. Every one of them is still a place where understanding can drift, and keeping each one current still takes time. The leads also become bottlenecks, because every update that crosses teams has to pass through them. As an organization grows, more of everyone's time goes to talking about the work instead of doing it.

Figure 2. Six people, three ways. If everyone syncs with everyone, there are 15 lines to keep current. Split into two teams whose leads sync with each other, there are 7. With one shared picture, each person keeps a single connection: 6 in total.

Fred Brooks made this point in The Mythical Man-Month (1975), a set of essays drawn from his experience managing the development of IBM's OS/360 operating system in the 1960s. The book is best known for what became Brooks's law: "Adding manpower to a late software project makes it later." Part of his explanation is exactly this math. New people have to be brought up to speed, and then everyone has to stay coordinated with them. In his words: "Intercommunication is worse. If each part of the task must be separately coordinated with each other part, the effort increases as n(n-1)/2."

5. Coordination systems, and the case for a tool

If every line of communication has to be maintained person to person, the cost of keeping everyone in sync eventually swamps the work itself. The alternative is to give everyone one shared place to look.

A coordination system, as I define it, is the set of tools, rules and habits a group uses to keep its shared mental state in sync. Meetings are one kind. Email and chat are others. A project management tool, used well, is the strongest kind I've found. Instead of every person updating every other person, everyone updates one shared picture and reads from it. The job of any coordination system is to create a shared understanding across many brains without requiring every brain to talk to every other brain directly. The best version is a central tool with a simple structure, written in clear, plain language that everyone reads and writes in.

None of these replaces the others. Meetings, chat, email and a project management tool each have their own value, and a good coordination system uses all of them, with the tool at the center.

A project management tool is the strongest option because it does things that meetings, chat and email can't:

Meetings still matter for the things that work better in real time: debating an open question, making a decision on the spot, and building the relationships that make a team trust each other. Those are hard to do well in comments. Everything else (updates, status, who's doing what) can live in the tool, which saves everyone the meeting.

But a coordination system only works when everyone uses it. If one person on a team keeps their work in the project management tool and the rest don't, that person's updates never reach anyone, so they end up repeating them in a group chat, over email or in the next meeting. If others work together without updating the tool, the person who relies on it falls out of the loop and needs a meeting just to catch up. A system that is only partly shared carries the costs of both approaches.

Two terms are used throughout the rest of this writing. The tool means the project management tool. The system means the coordination system as a whole: the tool, plus the rules and habits for using it.

Most organizations aren't missing a coordination system entirely. Many already use a tool. They just don't use it well, and I think that's because they undervalue it: they don't see how much depends on it, or how much depth it takes to get it working. The rest of this writing is about that depth. Part Two covers what the system has to keep in sync, Part Three the principles that keep it alive, Part Four how to run it day to day, Part Five how it breaks, and Part Six how to tell whether it's working and where this goes next.


Part Two. The framework

Part One described the problem: people can't keep what's in their heads in sync, and the cost of trying grows with every person. Part Two describes what a coordination system has to handle. It starts with what has to be true for people to succeed in a group at all, then narrows to the part a system can build: the five things that have to stay in sync.

Both lists in this part came out of the same process. I debated the ideas back and forth, on my own and with AI, and asked it to find loopholes and gaps in the thinking. The goal was the smallest set of pieces that covers everything, with nothing missing and nothing overlapping.

6. What has to be true

For people to succeed in a group, four things have to be true at the same time.

  1. They need to KNOW what to do. What's the goal, who owns what, what's the priority, what's the current status, and what depends on what. This is the visible, systematic layer, and it's where a tool adds the most value.
  2. They need to WANT to do it. Buy-in, motivation, and personal incentives lined up with the mission. If people don't want to do something, there's a good chance they won't, and they surely won't do it well.
  3. They need to be CAPABLE (CAN) of doing it. Skill, judgment, standards and energy, and the time and capacity to do the work well. A perfectly coordinated team that can't do the work is useless, and so is a capable person who's overloaded.
  4. They need the TRUST to do it together. Trust, transparency, good communication, psychological safety, willingness to disagree, and the ability to give and take hard feedback.

Figure 3. The four prerequisites. A coordination system handles KNOW directly and supports the other three.

This list was inspired by Alex Hormozi's Management Diamond (Acquisition.com), a framework for working out why someone isn't doing what you need. In his version, they don't know what's expected, don't know how to do it, don't know when it's due, lack the incentive, or something is blocking them.

A perfectly coordinated team (KNOW) that doesn't want to be there (no WANT) is useless. A motivated team (WANT) with no system (no KNOW) is chaos. A trusting team (TRUST) without the capability or the time (no CAN) fails with the best intentions.

This writing is about KNOW. A coordination system handles KNOW directly. It can't create motivation, capability or trust on its own, but the four aren't separate. Getting KNOW right supports the others: clear goals and ownership make the work easier to want, make capacity easier to plan, and give people fewer reasons to distrust each other. The other three deserve their own writing (see chapter 30).

KNOW breaks down into five things that have to stay in sync, which the next five chapters cover. They're the answers to five questions every person on a team should be able to answer at any time: What are we trying to achieve? Who owns what? What matters most right now? Where do things stand? What depends on what?

Figure 4. KNOW breaks down into five dimensions, each answering one question.

7. Goal

The goal is the big thing the organization is always working toward: its mission or vision. It's the reason the organization exists, and it tends to last. It can change over time, and there can be more than one, but there are usually very few. Everything else in the system exists to serve it. How to choose a mission or vision is its own subject. What matters here is that all the work traces up to it.

Initiatives are how the organization pursues the goal, and each has metrics that show whether it's working (chapter 19). Sometimes one initiative is enough.

Everyone should be able to say how their work connects to the larger objective, and ideally to its results. Task, to project, to initiative and its metrics, to goal. The system needs a visible hierarchy that runs from the top-level objectives down to individual tasks, and shows how they connect. Without it, you get an organization of local optimizers: people doing great work on things that don't matter.

Figure 5. Every task should trace up, step by step, to the goal it serves. The examples are generic.

8. Ownership

Every piece of work is owned by a person. Always one human. It might be a team member or a team lead, but it's always one person. A team can be responsible for an area of work, but within that team, one specific person is responsible for each piece of it, and one person, the team lead, is responsible for the team as a whole.

Ownership is singular at each level and layered across levels. One person owns an initiative, someone else owns each project within it, and someone else owns each task within those projects, or the same person owns several layers. Leaders and team leads also do work of their own, so they own projects and tasks too. In a small company there may be no team leads at all, just leadership and the team. Then leadership acts as the team leads. Everyone owns something.

Figure 6. Ownership is layered. In a small company, one person often owns more than one layer.

To own a piece of work, a person needs three things:

  1. It's clearly theirs.
  2. They have the context to do it.
  3. They have the authority to make the decisions within it.

When any of the three is missing, the person has been assigned the work without owning it. People who are only assigned work do the minimum needed to avoid blame. People who own it do what it takes to make it excellent.

The third condition, the authority to decide, is the easiest one to leave out. When nobody is sure a decision is theirs to make, it doesn't get made, and the work stalls.

There's also a limit to how much one person can own. When one reliable person keeps taking on more, ownership stops being layered and collapses onto a single name, and that person becomes the bottleneck for everything.

9. Priority

Priority is about relative importance, not labels. "High priority" means nothing on its own. It only means something if a meaningful amount of work is marked lower priority. If ten tasks need doing and you mark all ten high, congratulations, your work now has zero prioritization.

So the system needs forced ranking. If you add something to the top, what moves down?

An interesting aside: Greg McKeown notes in Essentialism (2014) that "priority" came into English in the 1400s as a singular word, meaning the very first or prior thing. It stayed singular for about five hundred years. Only in the 1900s did people start talking about "priorities."

Priority is also about opportunity cost. Every hour spent on one thing is an hour not spent on anything else, and the cost of a choice is the best option you gave up to make it. Seen that way, setting a priority means choosing what to give up.

Priority is also a question of capacity. Priority is what you're doing at the expense of everything else, and capacity is how much room that leaves. Working on fewer things means more energy for each one.

10. Status

Everyone should know where things stand, at the small and large scale, without scheduling a meeting. The moment updating status becomes its own task, you've lost. Status has to be a byproduct of doing the work (the entropy principle, in chapter 13).

Status is only useful when it's clear what finished looks like. A good task is simple to know when it's complete. A good project has a clear finish line, instead of ongoing work that stays open forever. When work is defined that clearly, its status means the same thing to everyone who reads it.

Status also depends on language. If a task says "almost done" or "working on it," different people will read it differently, and their pictures drift apart again. Clear, plain wording is part of what keeps everyone's picture the same, and chapter 20 comes back to it.

11. Dependency

A dependency is a link between two pieces of work: one can't start or finish until the other is done. This one is underrated. Dependencies ripple across and up an organization. Task A depends on Task B, which blocks a project, which blocks an initiative, which limits an outcome, which constrains the whole business. That's easier to see than to read.

Figure 7. How one dependency ripples up through an organization.

Most dependencies live in people's heads. That's why teammates keep following up with each other asking when work will be done. Nobody can do their part without knowing when the work they depend on will be ready. A website or a product launch needs creative, fulfillment, manufacturing and more. A logistics coordinator shouldn't have to call the creative lead, the fulfillment lead and the manufacturer just to figure out when to start. They need one central place to look. And when one of those people changes their mind, the whole group shouldn't have to get back in a meeting.

Everyone who works inside the system is a participant in it. Every organization also depends on people outside it: contractors, vendors, clients. Call them external participants. They aren't in the system, so they need someone inside to represent them. The dependency has to exist in the system and be owned by a participant.

12. Who's in the system, and how they use it

One simple way to divide an organization for this purpose is into three building blocks: leadership, team leads and team members.

Leadership plans the work with the team leads, and team leads plan and execute it with their teams. Anyone can still talk to anyone, and team members often coordinate across teams directly, but those are the main lines of planning.

Everyone also uses the tool in two ways. Doing is working in it: moving tasks forward, commenting with another team, posting updates. Seeing is stepping back to look at timelines, milestones and how the work went. Seeing isn't only for leaders; anyone can look at their own work this way.


Part Three. Principles

Part Two described what a coordination system has to keep in sync. Part Three covers the principles that keep it working over time. A system can be set up perfectly and still stop matching reality within a month. These six principles are what prevent that.

13. Entropy

Every project management tool takes some work to keep up to date. No tool runs itself. The goal is to make that work as small and as useful as possible.

The best way to do that is to make updating the tool part of doing the work. When you start a task, you mark it in progress. When you finish, you mark it done. That is the status update, and nobody needs a separate message or report.

When updating the tool becomes a separate chore, people put it off. The tool drifts away from what's really happening, and once people notice, they stop trusting it. That slow decay is what this writing calls entropy.

AI makes keeping the tool current much easier. Many people already work through an AI assistant, and when that assistant is connected to the tool, asking it to update the tool takes one prompt. Many project management tools can be connected through MCP (the Model Context Protocol, a standard way for AI assistants to work with other software). The responsibility stays with the person: review what it writes (chapter 28).

Even with good habits, things get messy. Work comes up in the middle of other work, and nobody can keep everything perfectly organized in the moment. So set up a short weekly cleanup: check for tasks that are stale, unowned or out of date. A one-off cleanup doesn't hold for long, so make it a recurring one.

14. Keep it lightweight

Every task you create is a task you have to keep up to date. The fewer and better the items, the easier the tool is to read and the less it costs to maintain.

If I can condense five tasks into one, I'll do it. Planning well takes some finesse, a real craft to building projects and tasks so that someone opening the tool isn't overwhelmed about what to do. Don't make four projects when one will do, or thirty tasks when five will. The aim is the fewest, clearest units that represent the work.

Fast work is a good example. If a team is going to finish a packaging run in one late-night session and pivot ten times along the way, writing ten tasks for the steps ahead of time costs more than the plan is worth. One task that names the action ("Finish the packaging run"), marked in progress at the start, with a short note at the end on what got done and what changed, keeps the record without slowing anyone down.

How organized is organized enough? There's no definitive answer. This is what I've come up with while writing this:

The detail in the tool serves both. Other people need enough to understand what you're doing and stay updated. And it should help you: you want to know where you left off and what the next steps are, so you can stay focused.

A sign someone has over-planned is frustration with how much maintenance it takes to keep their plans up to date. That's subjective too. Someone who loves planning might never feel it, so the absence of frustration doesn't prove the plan is the right size.

Avoid redundancy. A lightweight system doesn't record the same thing twice, and dates are a clear example. Projects have deadlines, and milestones carry dates. Say a project has a milestone, "Design complete," due at the end of the month, with six tasks inside it. Most of those tasks don't need their own date, because the milestone's date already covers them. A task gets its own date when it genuinely needs one: when it has to happen on a specific day, like paying a credit card, or when it has to be done before the rest of the milestone can move. Hundreds of tasks, each with its own due date, can be a sign the plan has become too heavy. If it gets to the point that dates stop meaning anything, people stop trusting and adhering to them.

15. Flow in a box

Flow in a box is a phrase Gerry and I came up with for how creative people can stay organized without losing their flow.

Say someone wants to build a new website over a three-day sprint, working hours a day with their creative flow completely uninterrupted. They can do something as simple as create one task in the project management tool for the entire site, mark it in progress when they start, comment on it once a day or once at the end, and mark it complete. That's all the system needs from them. If you also want project-level tracking, such as a timeline or project updates, make it a small project with one or two tasks inside it instead. Either way, the middle stays free.

The system sets the edges of the work (what it is, who owns it, when it starts and when it's done) and leaves the middle alone. That's the answer to anyone who says structure kills creativity.

Figure 8. Flow in a box: the system sets the edges, and the middle is free.

The same idea guides what goes into the tool. Tasks and projects should represent the actual nature of the work. If you have an idea for another department, don't rush to put it into motion before it's thought through. Instead, represent what the work really is right now: a task for yourself to explore the idea and come up with a plan, or to build it into a proper project. Exploring and brainstorming are real work too, with an owner and a finish line.

For everything in between, most tools have an intake inbox. Linear calls it triage: a holding area where new, unprocessed work lands before it joins the organized work. Put things there messy, then clean them up and decide where they go before they enter the main system. Chapter 22 covers triage in detail.

16. Visibility needs a reason

Visibility is good. Visibility without trust feels bad, and so does visibility without believing the tool is valuable.

If you think I'm asking you to put your work into the tool to micromanage you, you're going to resent it. If you understand that we want it there as a team, because your work affects other people and working as one unit is the whole reason an organization is effective in the first place, it feels completely different. And it helps you too: as chapter 2 argued, even working alone, structure is what gives you focus.

One way to see this is a simple two-by-two of trust and visibility. High trust with high visibility is accountability with support. Low trust with high visibility is surveillance with anxiety. The visibility is the same in both; trust is what changes how it feels.

Figure 9. Trust and visibility.

Leaders do need oversight. They don't need oversight just to watch you.

Access follows the same logic: people should see what they need to see. Most work can be open to everyone. Some work, such as finance, customer data or leadership's own planning, needs to be restricted to the people it concerns.

I've read parts of Ray Dalio's Principles, and one of his principles makes a strong case for radical transparency inside an organization: sharing information openly by default, with a few exceptions such as private personal information, so that problems surface and everyone can help solve them. The practical lesson I take from it for a coordination system is that visibility works best when people understand why it's there.

17. Measure outcomes, not activity

Be careful which numbers you track, because people will play to them.

Start with the most tempting number in any project management tool: tasks completed. It's a poor measure on its own, before anyone games it. People structure their work differently. One person might write one task where someone else writes four for the same amount of work. The second person looks four times as productive, even though the first may simply be condensing their work, or spending their time on higher-leverage work that fits in fewer, bigger tasks. Comparing people by tasks completed rewards whoever splits their work the finest.

Tracking it makes it worse. This is Goodhart's law, named after the economist Charles Goodhart. The anthropologist Marilyn Strathern put it in the form most people quote: "When a measure becomes a target, it ceases to be a good measure." Once people know a number is being watched, they change their behavior to move the number instead of the thing it was meant to reflect. If people know tasks completed is being tracked, they'll create more tasks for the same amount of work. It may not even be deliberate. Someone might just decide they should be more organized and start splitting their work finer. Either way, the number goes up and the work doesn't change. So never tell someone "we're tracking the number of tasks you complete."

Numbers are still useful though. A few uses I've found valuable:

And because the record of what was done lives in the tool, AI can analyze it and summarize the patterns. Even then, the numbers that matter most live in the business, not in the tool, and measuring people well takes judgment alongside the numbers. Chapter 29 comes back to this.

Patrick Lencioni (The Table Group) gets at one right use of measurement in The Truth About Employee Engagement (first published as The Three Signs of a Miserable Job). He names three causes of a miserable job: anonymity, irrelevance and "immeasurement." Immeasurement is the inability of employees to assess for themselves their contribution or success, which leaves them relying on someone else's opinion to know how they're doing. That points to one purpose of measurement in a coordination system: helping people see their own progress. It isn't the only purpose. Part of leadership's job is making sure the organization is flowing, and they can't do that without seeing the work. What matters is how the numbers are used: to understand and improve the system. Turning one analytic in the tool into a person's target can be where it goes wrong.

18. One source of truth

If it's not in the tool, it's not happening. That can feel strict at first, but the logic is simple: work that isn't in the tool is invisible to everyone who depends on it. If someone hands you work outside the tool, the right move is to get it into the tool before you act on it.

I believe everyone should be in the tool, leaders included. It has never been easier. An AI assistant with access to the tool can add or update work in seconds, and so can an executive assistant. Leaders who also do hands-on work need that work in the system for two reasons: to set the example, and so the team knows what's going on. How the work gets in matters less than that it gets there.

Leaders who don't do hands-on work still need to be in the tool, because that's where the leadership view lives: initiatives, project timelines and project updates. A leader who reads those before meeting with the team walks in already knowing where things stand, and doesn't have to relay updates to everyone else who needs them. The meeting can go to decisions instead of catching up.

Having someone else keep the tool updated for you can work, and hiring help for it is valuable. There's a known trap, though. While having AI do background research on the history and science behind some of these ideas, we came across a 1988 paper by Jonathan Grudin, a researcher who studied why software built for groups so often failed. One of the main reasons he found was "the disparity between those who will benefit from an application and those who must do additional work to support it." His example was automatic meeting scheduling. For it to work, everyone had to keep an electronic calendar up to date. The benefit went mainly to the managers scheduling meetings, while everyone else did the extra work of maintaining their calendars. In practice, many people didn't, and without everyone's calendar the feature couldn't do its job.

The same thing can happen when an assistant carries all of a leader's updates: the assistant does the extra work, and everyone else gets the benefit. It works when that work is recognized and kept small, when the leader still uses the tool themselves, and when the leader shows the assistant how much value their work creates. That's Lencioni's point about irrelevance again: people need to see that their work matters.


Part Four. Running it

Parts One to Three covered why coordination matters, what a system has to keep in sync, and the principles that keep it alive. Part Four covers how to run it day to day. It follows Linear's structure because that's the tool we know best. Most tools have an equivalent for each piece, and the principles don't depend on any of them.

19. The structure of work

Everything sits in one hierarchy: initiatives, then projects (with milestones inside them), then tasks (issues). Initiatives and projects can span several teams. A task belongs to exactly one team.

Figure 10. The structure of work, drawn like a simple data model. Each level holds many of the level below it.

Initiatives are the highest-level objectives, and they're how the organization pursues its goal (chapter 7): outcomes leadership would decide to continue or stop on their own. A good test: would leadership debate whether to keep doing it at all, or only talk about how it's going? If it's the first, it's an initiative. If it's the second, it's a project. Each initiative has one owner, a measure of success and a target. "Grow monthly revenue to $100K by June" is an initiative: it's an outcome, it has a number, and leadership would decide whether to keep pursuing it. Keep the number of initiatives small.

Deciding what an organization should work on is its own subject, and it overlaps with finding the constraint (chapter 30). What follows is a rough guide to what makes a good initiative.

Deciding what counts as an initiative is harder than it sounds. A few ways to find them:

Then test each candidate. Would leadership decide on its own whether to continue it? Does it have one owner, a measure of success and a target? Is it too big for a single project? If the answer to all three is yes, it's an initiative.

Fewer is better, and it's fine to start with one. When we restructured our own tool, the whole company was driving at one goal, so we started with a single initiative for it and rolled everything up into it. More can come later, once there are team leads to own them. Linear's docs describe initiatives as a way to "group projects around company objectives," and Linear supports sub-initiatives that "ladder up to broader company goals," so the structure can grow with you.

To define an initiative, ask two questions. What are the biggest constraints holding the organization back from its goals? And what outcome, or better, what specific metric, would mean the constraint is solved? They're easy to write down and hard to answer well.

Projects are bodies of work that serve an initiative. A project must be discrete: it has a start and an end, or at least a condition that makes it complete.

Don't use projects as bins for work. A bin is a project for an ongoing area, like "Marketing" or "Operations," that never finishes. Bins pile up, because there's always another area, and each one shows as in progress forever. Eventually there are so many open projects that they stop meaning anything, and nobody can tell which ones matter most. Projects only help people focus when each one is a finite piece of work that can actually be finished.

I learned this with my own work. I handle finances, and finance has lots of recurring tasks: paying credit cards, running financial models and so on. When I started using projects properly, I wanted to put all of those recurring tasks into a "Financial Management" project. It would have shown as in progress forever. Instead, recurring work stays off projects as standalone, properly labeled recurring tasks, and I still group most of my other work into projects.

A good project is lightweight: a clear name, a couple of milestones, and a few tasks under each. It has one lead who owns the outcome. When a project closes, whatever is still open in it gets a quick decision (done, canceled or moved) instead of being left behind.

Milestones are checkpoints inside a project. They're outcomes, not tasks: "Design complete," "Beta shipped." I prefer to put dates on milestones rather than on individual tasks, so the timeline lives in one place. That's a personal preference, but it keeps things simple (chapter 14).

Tasks (issues) are the units of work, the actual doing. A task should be completable by one person. Once it needs several people, it's either several tasks or a project. Every task has an owner (the assignee), a priority and a status, and it can belong to a project and a milestone. Two more fields are recommended:

A good task makes the next move clear. The title is one specific action, clear enough to understand from a list. The description scales with the work. One or two sentences is plenty for something simple. Important or cross-team work also covers why it matters, the context the owner needs, what done looks like, timing, and anything blocking it.

Subtasks (sub-issues) are for when you need them, and only then. A list of steps one person works through is a checklist inside the task. A piece that needs its own owner, its own status or its own dependency is a separate task.

How much structure a team needs depends heavily on the team. The simpler the better: use the fewest and simplest units that do the job.

20. Naming

Good names do a lot of the coordinating. Use one simple pattern for each level:

Read from the top down, the names answer three questions: why we're doing this, what we're delivering, and what someone needs to do next.

A few more habits help. Keep internal codenames and program labels out of names. Write names the way a person would say them out loud. And keep em dashes out of names. That one is a personal preference, and here's the reasoning: AI models tend to write with the same habits, and em dashes have become one of the most recognizable. Writing that reads like AI gets associated with AI slop, and with the fatigue of reading it. Even when AI helps you write, keeping its habits out makes the writing feel more human, and a plain name reads better anyway (just my opinion).

21. Teams

Teams in the tool are groups of people who work together and need to see each other's work. In Linear, a team has its own tasks, its own workflow and, if it uses them, its own cycles; other tools organize this differently. Recommendations:

22. Triage and requests

Triage is one of the most useful features in Linear, and one of the most useful ideas in general. Linear describes it as "a special inbox for your team." It's the entry gate to the system: anything can be dropped there quickly and messily without cluttering the organized work, which keeps the rest of the system in order. Later, it gets cleaned up and moved to where it belongs.

There are three main ways to use it:

  1. An inbox for messy work. When something comes to mind in the middle of a meeting or another task, drop it into triage without worrying about making it clean.
  2. Handing work to someone else. When you need something from someone, create the task (issue) in their triage. If you drop it straight into their tasks as Todo, or into their current cycle, you've committed their time without asking and pushed it into a plan they already set. That interrupts their flow. Triage lets them see the request, accept it and decide where it fits in their own work.
  3. A default for recurring tasks. A recurring task is one the tool creates automatically on a schedule, like a monthly bill payment or a weekly report. Setting recurring tasks to land in triage means each one shows up in your inbox and gets accepted into your work, so nothing appears unnoticed.

Process the triage every day, down to zero. Give each item a clear title, a description, a priority and an owner, plus an estimate and a label if you use them. Then decide where it goes (chapter 23): into the current plan if it has to happen now, into the backlog if it's not now, or closed if it doesn't matter. Nothing should live in triage.

Figure 11. Triage is the entry gate. Work lands there messy and leaves it clean, headed for any status.

Who handles triage depends on the request. If you know exactly who on another team should do the work, send it to that person's triage. When you're not sure, it goes to the team's triage, and the team lead, or whoever the team has chosen, routes it.

The habit behind triage is useful far beyond a work tool. Capturing everything in one inbox, then processing it on a regular schedule, works for a whole life as well as for a team.

An inbox makes it easy to create work, which also makes it easy to create too much. Chapter 28 covers the worst version of that: AI slop grenades.

23. Statuses, backlog and cycles

A task moves through a small set of statuses. The names vary by tool; the common ones are:

Most tools let you add custom statuses too. A team might add In Review between In Progress and Done, for example. And work doesn't have to go through every step: something in triage can go straight to In Progress, or straight to Done if it takes two minutes.

Figure 12. The life of a task. Triage can send work straight to any status, and moving a task forward is the status update.

The backlog is one of the most useful ideas in the tool. It holds work that's real but not current. That work isn't forgotten; it just isn't competing for attention. Without a backlog, everything looks urgent. But you don't need to save everything in it. The Linear Method puts it plainly: "Important ones will resurface, low priority ones will never get fixed." Basecamp's Shape Up makes the same point: really important ideas come back.

Moving a task from the backlog to Todo is a commitment. If your team uses cycles, that's also the moment the task goes into a cycle. A cycle is a fixed window of time for work. One week is a good starting point, because people already plan their work by the week. Not everyone has worked in cycles, especially outside software, but almost everyone already chunks their work into a week to make it manageable. Any length that suits the team works: Linear allows cycles of one to eight weeks, and its Method notes that two weeks is the most common in software. Pulling a task into the current cycle means the team intends to finish it in that window, and anything outside the cycle is "not now." The end of a cycle is a natural point to look back: what was planned against what got done, what was added mid-cycle, and where work got stuck.

A cycle only helps you prioritize if it has a ceiling. Linear's cycle graph helps here: it shows how much work, in estimate points, was scoped into the cycle against how much got completed, and Linear can suggest a capacity based on the last three cycles. Over time that teaches a team how much it can really finish. It matters beyond one team, too. If a team plans double what it can do, every team that depends on it gets thrown off.

A weekly rhythm we're working toward. At the start of each cycle, each team plans its week, and AI in the tool, or a person, drafts a short plan document to share. During the week, the team does the work and posts project and initiative updates, which are one of the most important parts of the whole system. At the end of the week, AI or a person pulls the statuses and updates into a report document to hand off to everyone else.

Figure 13. A weekly rhythm: plan, work and update, report, repeat.

In Progress should mean someone is actually working on it. When you start something, move it to In Progress. When you finish, move it to Done. That's the status update. If something worth noting comes up while you work (a decision, a question, something that didn't work), put it in a comment on the task. The task is the single source of truth for that piece of work.

Stale work needs a decision. When a task has sat untouched for weeks, close it, reassign it, or move it back to the backlog. My own rule of thumb: if something has been stale for 30 days and isn't urgent, delete it.

Priority in the tool (urgent, high, medium, low or none) only works if it's honest. If most of the work is marked urgent or high, none of it is (chapter 9).

24. Dependencies and getting unstuck

Linear lets you link tasks to each other with explicit relations, which is one of its most distinctive features:

Relations surface bottlenecks that would otherwise stay hidden, and they show why something matters. When three tasks are blocked by yours, you know people are waiting, and that changes how you prioritize.

You can mark your own work as blocking someone else's, so it's clear which of your tasks will unblock other people. Use relations when they matter: when a task is actually blocked, or about to be. Linking every distant dependency far down the line only adds noise.

When you're stuck, don't go silent. Comment on the task with what's blocking you, what you've tried, and who or what you need, and tag the person who can help. A blocked task nobody knows about is invisible.

If the blocker is an external participant, comment on your task and tag whoever internally owns that relationship (chapter 11).

25. Meetings, updates and documents

Meetings are great for decisions. Meetings held only to share updates are often unnecessary, because the tool can carry the updates. When you do meet, build the meeting around the tool: pull it up and work from it. A leadership meeting can run on the initiatives, walking through each one and the projects underneath it to drive the discussion.

Project updates carry the updates instead, and they're one of Linear's best ideas; much of this section follows its guidance. Each project lead posts a short written update on a regular cadence, usually weekly. Linear's advice is that a good update should be brief and to the point, "almost like a tweet": part summary of what happened, part educated guess about what comes next. A good update says whether the project is on track, at risk or off track, what changed, what's blocked, what decision is needed, and what happens next. Different projects need different updates. A launch might need dates and risks; a long research project might need what was learned. The point is to explain to everyone else what's going on. "Working on it" isn't an update, and a project with no recent update is worth checking on. Initiatives get updates too, from their owners, summarizing what the projects underneath are doing.

Documents in the tool keep the thinking next to the work. Most tools, Linear included, let you write documents inside the tool. Keep working documents there: plans, meeting agendas, notes on decisions. They can link directly to the tasks, projects and initiatives they're about, so the thinking and the work stay connected. More permanent documentation, like SOPs, policies and files, can live in a separate knowledge base, or in the tool if it handles that well. Use your judgment.


Part Five. When it breaks

Everything so far describes the system working. Part Five is about how it breaks.

26. Three ways it breaks

Picture three people.

Each one needs a different fix.

27. Procrastinating in the tool

A system can decay from neglect, when people stop using it. It can also decay from use.

A tool makes it easy to procrastinate while looking busy. Instead of making a call, someone opens a task, pushes it back to the other person, or asks a clarifying question they could have answered themselves by making a reasonable assumption and doing the work. The task looks like it's in progress. The work isn't moving.

Part of this comes from the format. Comments are slow and back-and-forth. In a meeting, someone can push for a decision on the spot; in a comment thread, it's easy to reply and wait. That's one reason meetings still matter for decisions (chapter 25).

The deeper cause is usually ownership. The third condition of ownership is the authority to make the decisions within the work (chapter 8). When people aren't sure they're allowed to make a call, they push it back. The fix is giving each role clear autonomy: a plain understanding of which decisions are theirs to make. One simple habit helps too: before bringing a question to someone else, say what you would do. That way you learn how to make better decisions over time.

28. AI slop

AI is now part of the system. It writes tasks, drafts updates and processes meeting notes, and it can make keeping the tool current far easier (chapter 13). It can also flood the tool.

I'm very pro-AI. I use it constantly, and I wrote this with its help.

AI slop is really a lack of attention to detail. Thought through from first principles, it comes from taking shortcuts, taking the easy way, and not reviewing the output the way you know you should. The problem is the missing review. Behind it is a wish to skip work that can't be skipped yet: AI can't do all of the work for you flawlessly, at least not today. Whoever puts the work into the system owns it and is responsible for it, however it was produced.

Slop also creates fatigue, and the fatigue lands on the reader, not the writer. That's why it keeps happening: the person generating it doesn't feel the cost. I'd go further and call it unfair, even immoral. Clarifying your own thinking is the writer's job. Handing that work to the person receiving it wastes their time and energy and leaves them confused.

Avoid AI slop grenades. The tool makes it easy to create work, and AI makes it easy to create a lot of it. Don't spam tasks, and don't let AI spam tasks into your team. Don't create four tasks when one will do. Name every task properly. Put requests into the other team's triage instead of straight into someone's plan. And watch the defaults: one AI assistant we used marked nearly everything high or urgent until we tightened its instructions.

The fix is plain responsibility. Review what your AI writes before it goes into the tool. If it's writing poorly, fix it yourself, or change how you're using it. I've been building my own instructions for AI (skills) to help it write more naturally, and it's an ongoing project.


Part Six. Knowing it works, and what's next

Part Six covers how to tell whether a coordination system is working, and where this thinking goes next.

29. Measuring the system

What follows are ideas and examples, not a definitive method. We're still actively working on this ourselves. The general shape holds up, though: measure whether the system is healthy, whether work is flowing, and whether any of it produced results.

Layer A: system health. Is the structure being kept up?

Layer B: flow. Is work moving?

Layer C: outcomes. Did any of it matter?

Figure 14. The three measurement layers.

Layer A shows whether the system is set up correctly. Layer B shows whether work is flowing. Layer C shows whether any of it mattered. A team can have perfect health and great flow and still miss its outcomes, which is why C is the only layer that ultimately counts. A and B exist to predict and improve it. The hard part is that outcomes usually live in business data outside the tool, and the feedback loop is slow. For now, much of Layer C happens in regular conversations.

What the numbers can't see. Every measurement in the tool only sees what's been entered. If work isn't captured in the tool, most of these analytics simply won't work, and the system can look healthier than it is. There's no metric for what you don't know. That's why the human layer matters as much as the numbers. The best check is people: team leads assign and direct the work, so they usually know what's happening that the tool doesn't show. Ask them.

Comparing people. Numbers from the tool can't fairly compare one person with another, because people structure their work differently (chapter 17). Compare each person and team against their own past. Across people, performance has to be judged on results, together with the judgment of the leads who see the work every day. The tool's numbers are an input to that conversation, not the verdict.

30. What's next

This is a first version. Three areas deserve more room than this writing gives them.

Finding the constraint. Initiatives should come from the biggest constraint holding an organization back. Finding constraints is central to my work, and it deserves its own piece of writing: it needs more time and space than it gets here. Eliyahu Goldratt built a whole discipline around the idea with his Theory of Constraints, starting with The Goal (1984), and I first came to it through Alex Hormozi. A few mental models I use day to day:

WANT, CAN and TRUST. This writing covers KNOW. The other three prerequisites from chapter 6 (motivation, capability and capacity, and the relationships that let people work together) deserve the same treatment.

Scale. The framework was built in small companies, and it's written from first principles so that it applies well beyond them, to larger organizations and to groups that aren't businesses at all. Some of the practices in Part Four will need adapting as an organization grows. The first principles shouldn't.


Appendix: Making leverage useful

Everybody talks about leverage: getting more out of your time than the hours you put in. From what I've come across, though, I haven't seen it explained in a way you can act on. Here is my attempt.

I worked through this with AI, trying to turn it into something practical, and came up with two approaches.

The first sorts work into three kinds of leverage:

All three multiply your time, because they keep working after you stop.

The second approach scored work on a five-level scale, from level 1, basic execution, up to level 5, work that multiplies capability.

I prefer the first. Scoring how much leverage something has is hard and subjective, and it changes with every situation. As a way of thinking, a scale of leverage points you in the right direction. As an actual score, it doesn't hold up. The categories only ask what kind of leverage something has. Many entrepreneurs have their own lists of types of leverage, and people, systems and decisions show up in almost all of them in some form.

In practice, this becomes labels in the tool. Tag tasks that build people, systems or decisions, and make sure that work gets priority. It also explains one of the measurement traps in chapter 17: someone doing high-leverage work may complete far fewer tasks than someone who isn't.


Appendix: The ORGCORD cheat sheet

Some books collect their rules in one place at the end. Rob Fitzpatrick's The Mom Test does this well, and it makes the whole book easy to put into practice. This is ORGCORD's version: the principles and recommendations from this writing, in one list. The number after each one is the chapter it comes from.

The problem

The framework

Principles

Running it

When it breaks

Knowing it works


Read it on the site: org-cord.com
Download the PDF: orgcord.pdf
Just the cheat sheet: orgcord-cheat-sheet.pdf


Don't miss what's next. Subscribe to Justin's Newsletter: