Minimalist coding for causal mapping

Code “X influenced Y”, with a quote. Add nothing the speaker did not say.

The puzzle

You have a stack of texts full of causes

Interviews, diaries, reports. People keep telling you what changed and why.

Every one of those “why” statements is a causal claim. Your job is to record them so you can count them, compare them and trace them later.

The question is how much structure to impose when you write each claim down.

One sentence, two ways to code it

Someone says: “I was eating less and felt quite lethargic.”

Someone says: “I ate adequately and felt lively.”

Variable-based

Treat both ends as variables on a scale. Code it as

[amount eaten → energy level]

… a positive link: more eating, more energy.

But

I ate adequately and felt lively

… would be coded the same way. The two stories collapse into one.

Minimalist

Keep the speaker’s own words as labels:

eating less → felt lethargic.

The second story stays separate:

eating adequately → feeling lively.

Two claims, kept apart, because that is what was said.

The variable-based approach over-commits

To code a scale you have to invent machinery the speaker never supplied.

  • A variable Is “eating” continuous or yes/no? What is its opposite?
  • A function Linear? A threshold? Monotonic at all?
  • A polarity Does more of one mean more of the other?
  • Extra facts We also have to code that the person did eat that much, and did feel that way.

This is ontologically over-determined: more apparatus than the claim needs. It forces the claims into a system, when we only set out to record what a person said.

The minimalist stance

What we deliberately do not encode

Polarity no +/- by default

Strength how hard X pushed Y

Functions linear, threshold

Counterfactuals what if not X

Causal packages X and W together

Hidden meaning what they “really” meant

People rarely even imply any of these. So we do not invent them.

If a project really needs them, they are added later, as a separate act of judgement, never baked into the raw coding.

The 90% rule

90%

of explicit causal claims code cleanly as a single undifferentiated link.

The awkward 10%, such as enablers and packages, is hard to fit any framework. We handle it in only the write-up.

The coding scheme should concentrate on coding the 90% well.

Stay close to the cognitive surface

We code what the source says explicitly about causes and effects in single sentences or paragraphs.

We don’t normally worry with theorising about implicit meanings by piecing together different parts of the text.

Contradictions and nuances may come out when we view the map of all the individual claims.

This also keeps the task feasible at the scale of thousands of pages of text.

From claims to answers

Counts measure evidence, not effect size

The outputs can look like a quantitative model. They are not.

Citation count how many coded mentions support a link: volume

Source count how many distinct people mention it: breadth

Useful for prioritising and filtering. They do not tell you a cause is “stronger”.

Defer judgement into bundles

We code every causal claim willy-nilly, even incompatible ones between the same two factors.

A set of claims with the same X at one end and Y at the other is a bundle. The map shows one arrow; the database keeps every parallel claim behind it.

Quality, relevance and agreement get weighed later, on the whole bundle, once you can see how many sources stand behind it.

Let the labels do the work

There is no separate table of factors. A factor exists only by appearing in a claim.

  • In vivo Use the speaker’s words, then consolidate the overlaps later.
  • Tags in the label Mortality rate [Health] groups by theme without adding a causal factor.
  • Hierarchy with ; Healthy behaviour; hand washing keeps detail and a roll-up.
  • Recode Cluster or soft-match raw labels onto a tidy codebook.

Hierarchy gives you zoom for free

A label written General; specific carries both levels at once.

Detailed

New midwife training → Healthy behaviour; hand washing

Zoom to level 1

New midwife training → Healthy behaviour

Truncate at the ; and the map gets readable, with no underlying coding changed.

Only use ; when the specific factor genuinely rolls up into the general one. For a plain theme, use a tag instead.

Analysis is a filter pipeline

An analysis is one links table passed through a sequence of simple transforms like these.

Links › select sources › trace paths › zoom labels › bundle › map

Filter the same dataset with different filters to get different maps. Each map is the result of one such chain of filters. Order usually matters.

The transitivity trap

A pig farmer

the cash grant gave me more cash

A wheat farmer

more cash let me buy more seed

So cash grants lead to more seed? No. Each step is true for one person only. Two stories stitched into one that nobody told.

Source tracing keeps only routes that run all the way through within a single source. Every surviving path is one complete story told by one person.

Where it runs out

The hard 10%

  • Enablers The phrase book let the holiday produce enjoyment. A claim about a claim.
  • Blockers Forgetting it disabled the holiday’s power to please.
  • Packages You need an accelerant and a spark. Two links miss the conjunction.
  • Idioms “It went viral” packs a whole story into one factor. Code it as one.

We could add structure for these. We have not. The cost rarely repays.

So what

Minimalist, or barefoot, coding is a stance

Code “X influenced Y, with provenance”, and let the labels do most of the work.

We give up the simulation-style affordances of richer traditions. In exchange we get an auditable evidence base that scales to thousands of sources, works with AI assistance and stays close to what people actually said.

The hard cases still come up. We handle them in the prose rather than build them into the data structure.

Working paper: “Minimalist coding for causal mapping”. App: app.causalmap.app

Home