← Archive

The time traveler's credibility problem in engineering

Faster tools are making me rethink how much of a product's future we should build in advance, and which decisions can wait for evidence.

Published · Updated · 9 min read
  • engineering
  • architecture
  • ai

I like thinking about time travel. Recently, one part of it made me think about how we make engineering decisions.

Imagine arriving in the past with a clear memory of what happens next. You know which technologies become common, which ideas fail, and which problems people are about to face. You try to warn them. They listen politely, and then they carry on as before. From their side, you are a stranger making confident claims about things that have not happened yet.

Michael Stevens calls this the time traveler’s credibility problem in a conversation with Hannah Fry on The Rest Is Science. Knowing the future and giving someone a reason to trust that knowledge are two different problems.

A time traveler points ahead and says "This won't scale." Three teammates reply "How do you know?"This won't scale.How do you know??certainnot convinced yet
Being sure about the future and helping others believe it are two different problems.

There is something familiar about that in engineering. In a design review, someone looks at a proposal and can already picture where it will struggle. They want the team to act before the problem arrives. The team wants a reason to believe them.

Except we have one more problem than the time traveler: we have not actually been to the future. We have been to the past, many times, and we are guessing that the future will look like it.

Experience can make a prediction feel like a memory

“This architecture won’t scale.”

It is a useful concern to raise. An engineer who has worked through a painful migration or a system failure may notice something the rest of the team has missed. That experience deserves attention.

But it helps to separate two things that often arrive together. The memory is: “Last time we built it this way, it fell over.” The prediction is: “This time it will fall over too.” The memory is a fact. The prediction depends on the load, the shape of the data, and how people actually use the product, and all of these can be different this time.

A familiar design does not guarantee a familiar outcome. The product may grow differently. Its busiest operation may be something else. The feature we expect to become central may barely get used.

I understand the instinct to prepare. I enjoy these discussions myself. Thinking through where a system could go is an interesting part of engineering, and doing some work early can save a lot of trouble later.

The difficulty is knowing when we have moved from a likely need to a possible one. A design discussion can start with a real constraint and end with an architecture built around several things that might happen. Each addition sounds reasonable on its own. Together, they ask the team to maintain a future that has not arrived.

Two approaches. On the left, the team builds a path to five possible futures. On the right, the team builds for today, sets one signal to watch, and leaves the possible futures as dashed lines.Building for every futureBuilding for todaytodaytoday10x traffic10x trafficagents use itagents use itnever usednever usednew hot pathnew hot pathno changeno changea signal to watchfive things to build and maintainone thing to build, one signal to watch
Every future we prepare for becomes something we build and maintain today, whether or not that future arrives.

Experience helps us form better questions. It should also help us explain the conditions under which our concerns become real.

How a time traveler would earn trust

If I were stuck in the past, I would not start with my biggest prediction. Telling people that everyone will one day carry a computer in their pocket would not get me far. Nobody can check it, and it sounds strange.

I would start with something small and close instead: the result of tomorrow’s match, or a storm that arrives on Friday. Once a few of those come true, people have a reason to listen to the larger claims.

Engineering predictions can work the same way. “This won’t scale” is a large claim about a distant future. It is hard to agree or disagree with, so the discussion can turn into a contest of confidence. Smaller claims are easier to work with:

  • “With the current design, an export of 50,000 rows will take more than 30 seconds.”
  • “If the two customers we are talking to sign, we will reach that size within three months.”
  • “Moving the export to a background job later will take about a week.”

Each of these can be checked soon. Some will turn out wrong, and that is useful too. Over time, a team learns whose predictions hold up, and in which areas. Credibility comes from a track record, not from how sure someone sounds.

The cost of changing things deserves another look

A large part of the argument for building ahead is about the cost of changing things later. If a change will take months, starting early can be sensible.

My notes on this topic started with a shift in my own habits. Working with coding agents has changed what feels achievable to me. I am more willing to try an approach, explore unfamiliar code, or work through a change that I might previously have put off.

That makes me want to revisit some of my reasons for preparing so far ahead.

If a particular change has become easier to make, the balance may have changed too. We might be able to leave a decision open for longer, learn from actual use, and make it with better information.

There are limits to this. It helps to split the cost of a change into parts. Writing the new code is one part. Moving data, keeping existing behavior working, rolling out safely, and agreeing on the change with other teams are others. Agents shorten the first part a lot. They help much less with the rest.

A chart of the cost of a change over time. The curve for writing code was steep and is now much flatter with agents. The curve for data, live users, and other teams stays steep.cost of a changetime, size of the systemdata, live users,other teamswriting code,beforewriting code,with agentsagents help here
Agents flatten the cost of writing code. They help much less with data, live users, and coordination between teams.

So when I estimate a change now, I try to ask which part of it is expensive. If most of the cost is in writing code, the estimate I carry in my head is probably out of date. If most of it is in data or coordination, very little has changed.

Where our tools do shorten the work, I think we should let that change our decisions. Otherwise, we keep paying for early preparation using assumptions about effort that we no longer stop to check.

Faster building can also mean more unnecessary work

The same tools can pull us in the other direction.

A flexible configuration system or an extra service might once have taken enough effort to make us question whether we needed it. When an agent can produce the first version quickly, it becomes easier to say yes.

We still have to understand the result, review it, and keep it working. The next person has to learn why it exists. Future changes have to account for it. The cost of writing it went down, but the cost of owning it did not.

This is where I want to be more careful. I do not want to use faster tools only to fit more architecture into the same amount of time. I want some of that speed to give me room to keep the first version smaller.

One question helps me here: if this part did not exist, what would we do when the need arrives? If the honest answer is “build it then, in about a week,” we may not need it yet.

There is already uncertainty about who will use what we build. A workflow intended for someone in a browser might later be used by an agent. A feature we expect people to use occasionally might become part of an automated process. These are possibilities worth discussing, but they do not tell us exactly what to build today.

Trying to prepare for every version of that future can become its own source of work.

Give the concern something we can check

Consider a team building an export feature. The first version creates a file during the request. Someone points out that large exports could take too long and suggests moving the work into a queue with separate workers.

That might be the right design. Before choosing it, I would want to understand the expected file size, the time a typical export takes, and the limits of the request. I would also want to know how much work it would take to move the export later.

If the first customers already need large exports, we have a current requirement. If they need small files and the export code is easy to move, we may have room to start with the simpler version.

We can measure duration and file size, test beyond the expected load, and agree when to revisit the design. A short note in the design document is often enough:

Decision:        Create exports during the request.
Why:             Early customers export under 5,000 rows (about 2 s).
We expect:       Some accounts to reach 50,000 rows within six months.
Revisit when:    p95 export time passes 10 s, or any file passes 20 MB.
Watching:        Export duration and size, with an alert at 8 s.
Cost to change:  About a week to move exports to a background job.

This gives the concern a useful shape. The team can see what we expect, what evidence supports it, and what would change our decision. If the alert fires, nobody has to win the argument again. We agreed in advance on what would make us act.

It also gives the engineer raising the concern a way to be heard without having to prove that a failure is certain. Their prediction is written down, and it has a date to be checked against. That is how a time traveler builds a track record.

Leaving a decision open takes care

Waiting only helps if we can notice the problem and still have time to respond.

I find it useful to compare two lengths of time. The first is the warning window: the time between the first signal and the moment users feel the problem. The second is the time we need to make the change. If the change fits comfortably inside the window, waiting is safe. If it does not, we either start earlier or look for an earlier signal.

A timeline. From the first signal to the moment users feel the problem is the warning window. The time needed to make the change fits inside it, with room to spare.warning windowtime to make the changeroom to sparetodayfirst signal(exports pass 8 s)users feel it(exports time out)
Waiting is safe while the time we need to make the change fits inside the warning window.

This is also where faster tools help in a quieter way. When the time to make a change gets shorter, the same warning window leaves more room, and more decisions become safe to delay.

Some choices still need attention from the beginning. Access rules, data ownership, and promises made through a public API can be costly to repair. Some people call these one-way doors: once you walk through, coming back is slow or impossible. A faster coding tool does not make lost data recoverable or remove the work imposed on customers by a breaking change.

A two by two map. Hard to undo and sure we need it: decide now. Hard to undo but unsure: prepare a little. Easy to undo and sure: build it when it is next. Easy to undo and unsure: wait and watch.Prepare a littledata ownershipstorage formatDecide nowaccess rulespublic API shapeWait and watchextra serviceconfig systemBuild it when it is nextqueue for big exportsharder to undomore sure we need it
How hard a choice is to undo, and how sure we are that we need it, tell us how early it deserves attention.

For other choices, we can keep the code clear, make its behavior visible, and leave room to replace a part when we understand the need better. That is work too. It just serves a future decision without trying to make all of it today.

The trust I want to build in our tools comes from practice: making changes, checking the results, and learning which kinds of work they help us complete reliably. That gives us a better basis for deciding what can wait than a general promise that AI will make everything easy later.

Making the future easier to share

I still want to think ahead. I still want experienced engineers to point out risks, including the ones that are difficult to measure. But I want us to be clearer about what we know, what we expect, and what we can afford to learn along the way.

A time traveler needs people to trust a future only they have seen. As engineers, we are in a better position. We do not need anyone to take our word for it. We can explain the concern, make a small prediction that can be checked, agree on the signal that would make us act, and make sure we still have time to act when it appears.

For me, that is the useful change in perspective: becoming more comfortable leaving some questions open because we have a practical way to return to them.