The Work Isn’t the Work Anymore

A manifesto for rebuilding how software gets built

Software didn't get harder.

The environment around it did.

Somewhere along the way, building products stopped being about building. It became about coordinating, aligning, syncing, proving, reporting, translating, documenting, re-documenting.

And the weird part? We act like all of this is inevitable.

We've normalized a world where teams ship code in hours but need weeks of meetings, rituals, and approval paths to feel safe enough to do it.

That mismatch is the defining problem of modern software teams.

Not velocity. Not talent. Not tooling.

The shape of work is the problem.

And it's about to change completely.

The old world was built for scarcity

Most systems we run product teams on were designed for a specific reality:

• Engineering time is precious

• Shipping is expensive

• Mistakes are catastrophic

• Code is slow

So everything evolved to protect that bottleneck: ceremonies, documentation, artifacts, systems of record, planning cycles, sign-offs, instrumentation, status updates.

These weren't bad ideas. They were rational responses to scarcity.

When code takes months, you build processes that reduce uncertainty. When engineering is expensive, you justify every investment. When shipping is risky, you slow decisions down until they feel safe.

That's the world agile was born into. The world Jira was built for. The world roadmaps tried to make tolerable.

The entire operating system of modern product development rests on one assumption:

Engineering is the constraint.

But the constraint has moved

We're entering a different world.

In the AI era, engineering is becoming dramatically cheaper and faster - not because engineers matter less, but because the cost of execution is collapsing.

Cursor didn't just speed up coding. It exposed something deeper: when you make the bottleneck cheaper, the whole shape of the system changes.

If you can draft code in minutes, execution isn't the limiting factor anymore.

Everything else is.

• Deciding what to build

• Aligning on priorities

• Clarifying requirements

• Turning conversation into direction

• Capturing decisions

• Avoiding rework

• Coordinating across functions

• Translating intent into tasks

• Proving progress to stakeholders

The bottleneck is now coordination.

But the rest of the team is stuck in the old pattern - old rituals, old systems - built to govern scarce engineering time.

Engineering time isn't scarce in the same way anymore. Which means the system is miscalibrated.

Ceremonies were always a workaround

Let's say the quiet part out loud:

Most ceremonies we treat as "just how software is built" exist because our tools never captured reality.

• Standups exist because nobody knows what's happening

• Sprint planning exists because priorities are unstable

• Status reports exist because trust is low

• Backlogs exist because "someday" feels safer than "no"

• Roadmaps exist because everyone wants predictability in chaos

• Retros exist because the team is drowning and needs a ritual to admit it

And almost every artifact is a translation layer:

Meeting → Notes → Ticket → Work → Update → Deck → Decision → More meetings

It's not that teams love this. It's that teams don't have a better option.

So we produce artifacts to simulate certainty. We build systems to prove work happened. We create instrumentation not just for the product, but for people.

Not because we're irrational - because the system demands it.

Systems of record became systems of friction

We built "sources of truth" because memory was unreliable.

But look at what many systems of record actually do:

They force humans to perform administrative labor to keep the machine fed.

The work becomes "updating the work." The system becomes an end in itself.

And worse: these systems don't optimize for outcomes. They optimize for legibility.

They optimize for:

• Proving progress

• Tracking activity

• Reporting predictability

• Defending decisions

• Avoiding blame

They optimize for management comfort, not team momentum.

Which made sense when execution was slow and expensive.

But when execution is fast? It's drag. A tax. A coordination penalty paid over and over again.

If execution gets cheap, everything else has to collapse too

This is what we can't unsee:

When engineering speed changes by 10x, the rest of the workflow can't stay the same.

You can't have weeks of planning, days of alignment meetings, ritualized documentation, painstaking ticket writing, asynchronous follow-up chains, and status theater supporting a world where the build step is instantaneous.

That would be like inventing the car and keeping horse stables as core infrastructure.

The tools need to change. But more importantly, the assumptions need to change.

The old worldview: "Protect engineering time at all costs."

The new worldview: Stop wasting human time translating work into paperwork.

What replaces it?

Here's the future we believe in:

Software teams won't run on meetings → docs → tickets → updates.

They'll run on conversation → decisions → execution.

With the translation handled automatically.

Not by more templates. Not by better project management hygiene. Not by humans doing a second shift after meetings end.

But by an operating system that treats coordination as the primary work - one that captures what happened in real time and turns it into the outputs teams need:

Tickets. Decision logs. Plans. Risks. Stakeholder updates. Follow-ups. Alignment artifacts.

Without requiring everyone to stop building just to prove building is happening.

This is what Earmark is building

Earmark exists because the most important change in software isn't the code.

It's the workflow around the code.

If Cursor changed how engineering executes, then something has to change how the rest of the team operates.

Because if building becomes cheap, the systems that manage building have to become lightweight, invisible, and fast too.

Our bet is simple:

A lot of modern product rituals are going away.

Not because people will work less, but because we can finally remove the translation work that never created value in the first place.

We're moving toward a world where:

• Meetings don't create a second shift

• Artifacts don't require human assembly

• Status doesn't require performance

• Decisions don't disappear into chat logs

• Coordination doesn't consume the week

A world where the work is the work again.

That's the big goal: change the way software is built.

Not by making teams "10% more productive," but by deleting entire categories of work we mistakenly accepted as permanent.

That's the manifesto.

And we're just getting started.