A Template Learns Only After You’ve Done It

In Fecit, a template is a blueprint. Write down a task you do often, once and well, and you can spawn it into a record and actually run it. Preparation items, steps, the plan, the expected duration — everything you wrote on the template is copied onto the record and comes along.

But once you actually do it, something usually shifts.

You go shopping and toss one more stick of butter into the cart that wasn’t on the list. You rewrite the recipe’s “sauté the ingredients” into “sauté slowly over low heat.” You delete a step you turned out not to need. The record — the one you’ve actually run once — is a step ahead of the blueprint. And then that knowledge died inside the record. Spawn the same template next time, and you’d start over from the same list, butter missing again.

We decided to close that gap.

Drift: the distance between blueprint and execution

At the moment of spawning, the record and the template are identical. Then, as you touch things mid-execution, the record slowly pulls away from the original. We call this distance drift — exactly what the word means: to float gradually away.

Drift shows up in three shapes.

• Add — in the record, not in the template (you grabbed extra butter)
• Remove — in the template, dropped from the record (you deleted an unused step)
• Modify — the same item, changed (you refined a step’s wording)

This is of a piece with writing ‘if X, then Y’ on a task. There we wrote that a plan has to meet execution. Drift is the residue that meeting leaves behind. The trouble was that the residue stayed on a single record and never reached the blueprint.

You decide when to fold it back

At first we did this automatically — the instant a record was completed, the server compared it and spilled out suggestions. We quickly learned the cost: when every completion auto-generates, suggestions you never look at pile up on the template. Every one-off whim became a suggestion, accumulating as garbage.

So we made the fold-back something you call for.

A completed record is still a settled statement: this is how it actually went this time. When you open that record’s menu and tap Generate suggestions, Fecit lays it next to its origin template and compares — turning each difference into an improvement suggestion pinned beside the template. Only when you want it, never piling up.

What it compares: the plan (description), the expected duration, preparation (materials, tools, venue, personnel, qualification), and steps (subtasks) — add, remove, and edit alike.

How it knows it’s “the same item”

To tell add from remove from modify, you have to pair each item in the record with the item it came from in the template. Match by name, and the moment you rename something, you lose the pairing. Two items with the same name, and it gets confused.

So we stamped each preparation item with a stable key. The key rides along when the item is copied at spawn time, so a material on the record and the material it came from on the template share the same key. Rename “flour” to “cake flour” and the key holds — which is how we know it’s not a new item but the same item, modified.

Steps are a little different. A subtask is its own document, so at spawn time it already carries an origin pointer back to the template subtask it was duplicated from. We didn’t need to invent a key for steps — the trail was already there.

Like a PR — accept it or dismiss it

A suggestion is not a command. Like a GitHub pull request, it simply sits pending beside the template. A small icon lights up on the preparation section or a step header; tap it to open a review. “Add this material to the template too?” — apply, or dismiss.

A few things we quietly took care of:

• Idempotent — apply something already folded in, and it won’t duplicate.
• Dismissal sticks — say “no” once, and the same drift from another record won’t nag you again.
• Stale ones disappear — if you’ve since edited the template by hand, suggestions that no longer make sense hide themselves.

An accepted add does one more thing: it links the record’s item to the newly created template item. That way, completing the same record again won’t propose the same addition twice — the loop closes on itself.

The loop comes around

One axis of Fecit is that the goal → execution → reflection layering exists explicitly. Until now this arrow ran one way. A template begot a record, and the record was run.

Now there’s one arrow pointing back. Execution rewrites the blueprint. What you learned by doing it once no longer dies inside that record; it lets the next person — the next you — start from a slightly better-prepared place.

The more often you do something, the more the template comes to resemble how you actually do it. Not the blueprint you wrote down, but the blueprint you’ve lived.