r/Futurology

"In previous decades, the world’s fertility rate went down because couples had fewer children. Now the main reason is that there are fewer couples………………….across a wide range of countries, the decline in births and coupling is much steeper among those with the least education and lowest incomes. By contrast, the share of university graduates forming couples and having children is stable or even rising in some cases."

This makes me wonder about correlation and causation. If the poorer working class people acquired smartphones at the same time as their wages & housing opportunities drastically decreased, who is to blame for their lack of babies?

Ironically, the people who get most worked up about this issue are the least likely to countenance political changes that might reverse the trends. Anyway, today's 8 billion people seem like plenty of humans. Who cares if there's never 10 or 20 billion?

Why birth rates are falling everywhere all at once: Homes and phones are part of the reason for the demographic shift changing our world

I've been building multi-step prompt chains for about 18 months. Workflows where the output of one prompt becomes structured input for the next prompt, which feeds the next, which feeds the next. The kind of thing that takes a vague input ("I have a business idea") and produces a deliverable output ("here's a positioning statement, market analysis, and brand foundation") through five or six prompts run in sequence.

For most of those 18 months my chains underperformed. Each individual prompt was solid. The chain as a whole produced output that drifted, lost focus, or contradicted itself between steps. I kept improving the individual prompts. The chain didn't get noticeably better.

The problem wasn't the prompts. It was that I was treating the chain as a sequence of independent prompts when it's actually a single engineering artifact with multiple stages. Different problem entirely.

The structural difference between independent prompts and chained prompts:

An independent prompt has one job: produce a useful output from a known input. The input is whatever you paste in. The output is whatever the user does next with it. The prompt doesn't care about either.

A chained prompt has two jobs: produce a useful output, and produce that output in a structure the next prompt in the chain can reliably consume. The output isn't for the user - it's for another prompt. That changes how it has to be designed.

Most chain failures happen at the join points. Prompt 1 produces output that's useful for a human reading it but doesn't have the structure prompt 2 needs. Prompt 2 has to either guess at the structure or do extra parsing work, which degrades its own output. By prompt 4 or 5, you've accumulated three layers of degradation and the final output is meaningfully worse than if you'd written one big prompt that did everything in one shot.

The four engineering principles I now apply to any chain:

1. Output schema, not output style. Each prompt in the chain has to produce output in a parseable structure, not just a readable structure. This usually means specifying the output format explicitly: a labelled section structure, a markdown table with named columns, a numbered list with consistent fields. The next prompt knows where to find each piece of information because the structure is enforced.

Independent prompt output: "Here's a positioning statement for your business..." Chained prompt output:

## POSITIONING STATEMENT
[one sentence]

## TARGET AUDIENCE
[paragraph]

## CORE DIFFERENTIATOR
[paragraph]

## ASSUMPTIONS REQUIRING VALIDATION
[bullet list]

The second version is parseable by prompt 2. The first isn't reliably.

2. Explicit handoff instructions. Each prompt should explicitly state what its output will be used for downstream. Not because the model needs to know, but because the discipline of writing it forces you to design the output for the actual use case rather than for general usefulness.

Adding a single line - "This output will be passed to a market research prompt next, which will use the target audience and differentiator sections to identify competitive positioning gaps" - changes the output meaningfully. The model produces the audience and differentiator sections with more analytical sharpness because it knows they'll be analysed, not just read.

3. Failure mode propagation. When prompt 1 fails or produces low-quality output, prompt 2 doesn't know it's working with bad input. It just produces output one tier worse than its input. By prompt 5 the failure has compounded silently.

Chains need explicit failure handling at each join. Each prompt should check that its input has the structure it expects and flag if it doesn't. If prompt 2 expects a "TARGET AUDIENCE" section and the input doesn't have one, prompt 2 should say so rather than improvising. This catches degradation at the source rather than letting it propagate.

4. State that doesn't drift. Long chains tend to drift away from the original brief because each prompt only sees the immediate previous output, not the original input. By prompt 5, the work has often quietly diverged from what the user originally asked for.

The fix is anchoring. Every prompt in the chain after prompt 1 should receive both the previous output and the original brief, with explicit instruction not to deviate from the original brief unless the previous prompt's analysis explicitly justifies it. This adds tokens but preserves coherence over the length of the chain.

A specific example of these principles in action:

I built a chain for taking a rough business idea through to a usable founding document. Six prompts: niche validation, positioning, market research, brand foundation, visual concepts, pitch outline. The chain works because:

• Each prompt outputs in a labelled section structure the next prompt parses by section name
• Each prompt's instructions explicitly state what downstream prompts will do with its output
• Each prompt validates the structural integrity of its input before processing
• The original brief is re-passed with each step, with explicit anchoring to prevent drift

The full chain takes a 30-second input and produces a 4-page founding document. The same six prompts written as independent prompts and run in sequence produce a document that's structurally similar but consistently lower quality - the audience definition drifts between steps, the differentiator gets reframed, the pitch outline doesn't match the positioning.

Why this matters more than it sounds:

Most prompt engineering content focuses on single-prompt optimisation. The economic impact of well-engineered chains is much larger because chains can replace whole workflows that previously needed human coordination between stages. A six-prompt chain that runs reliably is worth more than 60 individually-excellent prompts run by hand, because the human coordination cost between independent prompts is enormous compared to the marginal output difference.

The chains that actually run reliably in production aren't sequences of optimised individual prompts. They're single engineering artifacts where the join points are designed at least as carefully as the prompts themselves.

If you want to see a working example of a chain engineered with these principles, I built a six-prompt sequence for taking an idea to a business founding document. Each prompt is structured to feed the next, with the join points designed explicitly. Free, signup-gated: https://www.promptwireai.com/businesswithai

Worth running it on a real idea you have rather than a hypothetical, because the chain's reliability shows up most clearly when the input is specific.

I'm referring to the study: https://doi.org/10.3389/fnhum.2026.1700499

You can find a few scientific diagrams I created here: (1) (2) and (3).

As per the main post: Any tips for turning this paper into clinical interventions? I would greatly appreciate it!

#stuttering #SLP #speech-therapist #research

Something I've been chewing on for a while, and I think it deserves more attention than it's getting outside the materials press.

Everyone tracking advanced nodes already knows the interconnect bottleneck is the quiet ceiling on scaling. Transistors keep shrinking, but the wires connecting them don't shrink for free... Below a certain dimension, copper stops behaving like copper. Grain boundary scattering and surface scattering start dominating, the effective resistivity climbs sharply, and the barrier/liner stack you need to keep copper from diffusing into the dielectric eats more and more of the cross-section. At sub-5nm linewidths, copper's effective conductivity can collapse into the 10⁶ S/m range. That's roughly an order of magnitude below the textbook number people still quote at conferences.

But...

A 2025 paper in Science (Khan et al., from Stanford) on niobium phosphide thin films showed something I keep going back to. NbP is a topological semimetal: that is surface states are quantum-mechanically protected against scattering. In a thick piece of NbP the bulk conducts worse than copper. Substantially worse, like 20× worse. So in any normal context, you'd dismiss it.

But because the surface conduction is protected and the bulk isn't, the ratio flips as you go thinner. The surface stops being a correction term and starts being the dominant channel. At around 1.5nm, NbP films hit ~3 × 10⁶ S/m. At that thickness, copper is below them. Further, the NbP films don't need to be single-crystal. That's a big deal for anything resembling a real fab process, because epitaxial growth on patterned wafers is a nightmare and one of the main reasons exotic interconnect candidates never escape lab demonstrations.

I want to be careful here. This is one paper, sub-5nm, on test structures. It is not a process. There's no integration story yet for liners, no etch chemistry, no reliability data, no EM lifetime, nothing about how it behaves over a few hundred thermal cycles next to low-k dielectric. The gap between "outperforms copper in a measurement" and "TSMC qualifies it for N2" is roughly the size of a decade and several billion dollars. Anyone who's watched cobalt's partial, awkward arrival as a local-interconnect material at the leading edge knows how slow this actually moves. Ruthenium has been "next year's thing" for several years.

But I am an enstustiatic when talking about developments and what makes me think this one is worth tracking anyway is the timing. The S&P Global 2026 outlook has copper consumption from data centers alone roughly doubling between now and 2040, from ~1.1 Mt to ~2.5 Mt. That's mostly because of busbars, power distribution, cabling, but the interconnect copper sits inside the same supply chain pressure, and it's the layer where the physics is breaking first. If the most advanced nodes are forced into a partial materials substitution at exactly the moment the rest of the grid is also competing for chip-grade conductors, the supply picture isn't going to look like the current projections.

The broader thing I keep coming back to: when we talk about "replacing copper," we're usually talking about four totally different problems that get collapsed into one: aluminum at bulk scale, CNTs in weight-critical applications, architectural workarounds like sodium-ion or HTS cables, and then this nanoelectronic regime where copper hits hard physical limits. The fourth one is the smallest by mass but the most interesting by leverage. A few grams of NbP in the right layers of a leading-edge chip could matter more, strategically, than a kilometer of aluminum cable.

The full deep dive with references you find it here: https://raw-science.org/en/copper-substitution/