I am one of those engineers who find improving deployment strategies catnip. At a previous company I set up a system where we get a change from our machines to prod in under 15 minutes. That included reviews, packaging, full testing, smoke testing with production data, canary deployment, automatic rollbacks, etc. Most companies don’t seek that level of efficiency, but in the age of AI, they are discovering the bottleneck was never the code, but the friction of deploying it. An AI agent can write a fix in 4 seconds. Getting that fix validated takes 4 days. Getting it to the customer takes 4 weeks.

The Karpathy autoresearch loop showed how agents can write code at machine speed, but only in a sandbox. Today’s human-gated deployment pipeline was built to stop humans from breaking 2004-era Java monoliths.

The Darwin Loop is a deployment architecture derived from first principles: minimize Entropic Action by reducing state-transition cost and complexity so iteration frequency can increase. This architecture, while faster for humans, is built for agents iterating at machine speed and unlocks the evolutionary dynamics needed for Recursive Self-Improvement.

Death by a Thousand Flags

A cited “best practice” for software deployment is the following:

1. Wrap a change in a feature flag and test locally.

2. Open a PR, get review/tests, merge to main.

3. Branch main for release, build, test, and canary-deploy.

4. Enable the flag, roll it out, and review metrics.

5. Iterate if problems arise; otherwise remove the flag.

While it is a best practice for some teams it can sometimes take months to get a change out. Feature flags were made to reduce the failure blast radius, but they bring problems of their own, including:

• Wrapping is manual, not always done and rarely complete.

• Flags become a shadow VCS with unbounded debt.

• 2^N states make reasoning/testing impossible.

• Three loops (PR, deploy, toggle) slow every change.

• Flags reused over and over to bypass infrastructure overhead.

• Some flags are permanently partially deployed or never removed.

• The joke, but not joke: do you have a feature flag to remove a fully deployed feature flag?

• The 2^N possible states turn database migrations and schema changes into high-stakes puzzles with no obvious safe path.

Feature flags are laundering complexity.

How did we get here?

We evolved our way here. Code reviews, unit tests, reproducible builds, canary releases, each layer tried to reduce the cost of a change and the cost if it went wrong. Two metrics drove everything:

1. Uptime: Deployments that bring down the site threaten revenue.

2. Deployment frequency: Releases contain features; delayed releases decrease revenue and decreases understanding about customer usage.

Feature flags will always exist because the business needs to be able to turn on and off full features. Maybe to delay a marketing campaign or to only allow features to specific customers such due to regional laws. When turning off a flag is faster than doing a release, pressure to wrap all changes in flags increases. This leads to Kate’s 15th software law:

Bespoke release processes reflect their environment:

• Mobile apps have a long external review cycle, so QA catch errors before release.

• Facebook’s “Move Fast and Break Things” used an hourly release train with canary deployment and automatic rollbacks. This worked in PHP, but as binaries and complexity grew, they eventually introduced a feature flag system.

• Uber lets engineers put changes in production so they could use it in the physical world, but only they can access it.

You could engineer your way out of each problem individually such as a language with built-in revision control and concurrent phenotypes. But to find the actual solution, we need to return to first principles.

The Thermodynamics of Shipping Code

Every deployment has a cost, and that cost comes from three things: how expensive the change is to make, how complex the system is, and how often you’re willing to try.

• ξ: (Transition Cost) the cost of moving code from a developer’s mind to production execution. The literal CPU hours, Slack notifications, and manual approvals to get a commit live.

• K: (Complexity) the structural complexity, the number of microservices or interconnected state systems that could break.

• f: (Frequency) how frequently customers could get new changes.

A company releasing once per decade (f=0.1) will likely be outcompeted by one releasing yearly (f=1). The uptime and deployment frequency metrics map directly to ξ and f. Early Facebook iterated fast (f) because PHP was simple (K) and cheap to deploy (ξ) with hourly releases and automatic rollbacks. This framing comes from my work exploring the physics of systems. I've mapped the thermodynamic concepts from my preprint on Informational Energetics: Entropic Action directly here to software terms.f

Feature flags fail catastrophically: they increase ξ (flag-flipping, monitoring, cleanup) while masking K (burying 2^N complexity inside branches). The system appears to manage risk but accelerates internal cost, something only FANG companies can subsidize.

Most teams already know where their ξ and K are too high and what is causing their f to be slow. The engineers who fix them usually start by noticing patterns like these:

• Before: A change waits a week for review because one person “has to” sign off. After: They wrote a test that exercises the condition, deleted the human gate, and the same change gets approved in twenty minutes.

• Before: Flaky tests turn every CI run into a dice roll. After: They quarantined the flakes, fixed the root cause (a race in the test harness, not the code), and time from PR creation to merge drops by a week on average.

• Before: “No Deploy Friday” became “only deploy Tuesday” became “batch for next month.” After: They added automatic rollback on error rate spike, deleted the policy, and found their incident rate didn’t change, but their feature velocity tripled.

• Before: A dormant flag collided with a new change and caused a Sev-1. After: They set flags to auto-expire at 30 days; if no one extends it, the flag dies and the collision becomes impossible.

• Before: Staging went down and fifty engineers went home early. After: They gave every engineer an ephemeral environment spun from their branch; “staging is down” became a non-event.

Ideal Architecture for Software Iteration

Agents can write code at machine speed. We need them to deploy at machine speed too. From first principles: maximize delivery velocity while minimizing total entropic cost.

1. Zero-Hysteresis Rollbacks (ξ → 0): A failed change simply ceases to exist. Zero cleanup, zero mutation, zero state pollution.

2. Single-Variable Universes (K → minimum): Test in absolute isolation. Exactly one variable in flight, not 2^N. No branching, no dead paths, no state debt.

3. Single-Loop Iteration (f → maximum): One continuous loop from code to production feedback. No separate PR, deployment, and flag-flipping cycles fragmenting f into discrete, expensive steps.

This is the architecture evolution already uses. In biology an organism expresses a variant; if it is fit, it propagates. If it is unfit, it dies. Organisms don’t validate in a simulation, but through increasing stages: can the DNA run? Can it find food? Can it grow? Then, can it mate?

The Darwin Loop

Changes progress through ever-increasing exposure, from successfully building to responding to live traffic. A survival filter continuously monitors health and only successful changes persist and propagate.

Survivorship Filter: Let Production Decide

The goal is to minimize cost and risk to the substrate. Like most deployment systems, this means verifying the build, running tests, then using mirror traffic, then actual production traffic. Each step increases potential cost.

Here is where the Darwin Loop diverges:

• Promote on validation, not on schedule. Once a change passes pre-production validation, there is no new fitness signal in waiting for a release date.

• Deploy to minimal exposure. If the only fitness signal is “does not crash on start,” survival may require only a single instance and a 200 from the healthcheck endpoint.

• Leave successful changes alone. A passing change stays live at whatever fraction of deployment it earned even if this is only 0.1%. New deployments replace the oldest, so production becomes a continuously evolving fleet of experiments.

The survivorship filter does not shepherd releases. It collects signals to kill what should not exist, including binaries previously assumed fit. It is also self-filtering: a binary that detects its own failure can self-select out before the filter acts.

The Fitness Function

Because every release must be measured for fitness, objectives are defined in a mathematically precise, machine-evaluable form. Elevated from deployment plumbing to a critical business tool, they become the single source of truth for product requirements, replacing the scattered organizational memory of Jira, Slack, and OKRs. They should span the full lifecycle: build latency, test coverage, resource efficiency, correctness, and customer-facing behavior. More signals mean sharper selection. What counts as a signal is itself a design problem, but that’s a separate essay from the architecture that consumes them.

With this in place, a Red Queen can be introduced: a co-evolving adversary that probes deployed binaries for novel failure modes such as security vulnerabilities, edge cases, resource exhaustion and records each discovery. For most this starts simple with fuzzing, something AI can’t hack around like it can with unit tests.

Reproduction: How Good Code Spreads

Source Reproduction:

A change reproduces only after receiving enough positive signals. For example, it then automatically merges into the main branch. Even if deployed to only 10% of machines, it eventually spreads to all of production as new changes incorporate and propagate it.

Binary Reproduction:

Newer, validated variants systematically replace the oldest changes. This bounds the half-life of any release without the latest changes, driving the population toward optimal fitness. This can even work without a centralized push: idle deployments check their own age and automatically request a replacement deployment.

Evolving State:

Stateful components still need coordination, but there is no need to go back to release trains. A binary can say: I need the fleet at version X before I deploy as one example of how this can be accomplished.

No “main” release, no deployment train

Even if changes are merged into main, there is never a release from a branch called “main.” Deploying main is not only superfluous, but implies a gatekeeper that owns the release when every change is already owned.

Once we have no need for a central main branch release, we can explore more powerful paradigms. In evolutionary biology, Muller’s Ratchet shows that a single, asexual lineage is a genetic dead end, doomed to accumulate deleterious mutations until it collapses under its own entropy. Species survive through genetic recombination: beneficial mutations from different lineages combine and spread while bad changes are purged. Even if GitHub privileges one branch by default, Git itself has no special branches. The Linux kernel operates this way: module and distribution owners merge from each other, and no single branch is sacred.

For agents iterating at machine speed, we can take this further. At the simplest, new changes start from a branch based on two healthy branches running in production: start from Parent A, merge in Parent B.

On the Dwarkesh Patel podcast, Andrej Karpathy noted that LLMs currently have no equivalent to AlphaGo-style self-play, no innate mechanism for beneficial variations to recombine and compound. Without it, naive self-improvement loops inevitably suffer from model collapse: Muller’s Ratchet manifesting in weight space.

Karpathy’s own autoresearch loop illustrates the gap: it generates hundreds of experiments and retains winners, but nothing combines two independent winners into a third. It also validates against a fixed eval script rather than live signal, so it optimizes toward whatever the script rewards without a Red Queen. Autoresearch nails single-loop iteration, but misses recombination and adversarial pressure, the difference between fast and evolvable.

The Darwin Loop makes software evolvable.

Recursive Self-Improvement with AI

Once deployment cost is minimized, the system can modify, test, and deploy its own changes. If objective metrics live in a separate repository, an AI has explicit, measurable targets to optimize against.

Most discussions of Recursive Self-Improvement focus on models improving their own weights. This architecture can do that, but the mundane applications matter more. A new crash at 2am. Before the on-call engineer is notified, an AI writes a fix, deploys it to 10% of production, and verifies it survives. By 9am it had propagated to 50% of the fleet. The human reviews it over coffee. A human is no longer needed to shepherd a change through release.

When human signoff is required, it can happen at any point such as before promotion to live customer traffic. Once given, everything downstream still happens automatically.

Most repositories only need a few changes a month and are fine with a “main” branch. By reducing the cost to make a change, an engineer spends less time shepherding changes through the release process and more time on fixes and architectural improvements. And by enabling AI to handle the smaller changes, someone who once maxed out at five repositories can now maintain dozens or even hundreds.

Conclusion: The Thermodynamic Advantage

This might feel like science fiction compared to what many are using at work. Many have felt the pain of current “best practices” intimately, but didn’t have the math to describe why. The Darwin Loop is the evolution of my older 15-minute pipeline and even before AI, the speed was wonderful to experience as an engineer.

Others have written about this future, but usually as a research curiosity about how to evolve code, not deliver code. They then go back to wrapping changes in feature flags. The Darwin Loop recognizes that the delivery layer is already a fitness function. There are a dozen reasonable ways to build this, and reasonable people will argue all of them. But they will all have the same shape dictated by the math: minimize ξ, minimize K, maximize f. Doing that improves human velocity just as much as agent velocity. An AI can write a fix in four seconds; the architecture that gets it to a customer in four minutes instead of four weeks is not science fiction. It is buildable now.

Previously we validated Informational Energetics (IE) against fundamental physics, deriving the fine-structure constant from first principles with zero free parameters and applied it to the brains cleanup system to give us an equation for Alzheimer’s. This post asks whether the same architecture appears in pure mathematics.

Riemann Hypothesis and the Mystery of the Primes

In analytic number theory, the distribution of prime numbers is governed by a series of beautiful, frustrating heuristics. We know the primes thin out at a rate of x/ln(x) (The Prime Number Theorem). We know the “error” in this distribution behaves remarkably like a random coin flip, bounded by sqrt(x)\ln(x) (Cramér’s model). And we strongly suspect that the zeros of the Riemann Zeta function all sit perfectly on a single critical line (The Riemann Hypothesis). When we look at these properties through the lens of IE, they are the exact thermodynamic signatures of a persistent information network.

The IE Rosetta Stone

Any system that persists against informational entropy must balance a specific six-pillar architectural ledger. It must have a Capacity (a substrate to hold states), a Map (irreducible, compressed data), a Protocol (the generative rules connecting them), a Governor (a stabilizing boundary), a Toll (the irreducible cost of encoding), and a Margin (a resolution floor of unresolvable noise).

If we treat the integers as an informational substrate, the architecture of analytic number theory align flawlessly:

• Capacity: The total system Capacity (the integer range x)

• Map: The primes

• Protocol: The Euler Product formula provides a standardized translation layer that multiplies the isolated primes back into the global integer substrate.

• Governor: The Riemann Hypothesis (zeros on the Re(s)=1/2 critical line). If the integers are a lossless information processor, their transfer matrix must be perfectly unitary (eigenvalues on the unit circle). The functional equation of ζ(s) enforces a reflection symmetry across Re(s)=1/2. For the system to be lossless (unitary), its spectral data, the zeros, must respect this symmetry exactly, confining them to the critical line. This is the Governor: the boundary constraint that prevents the system from exponentially diverging.

• Toll: The logarithmic encoding cost, ~ln x

• Margin: Cramér’s random-walk error bound (sqrt(x) ln x). The primes fluctuate precisely at the limit of irreducible statistical white noise.

The Prime Number Theorem emerges as the Shannon Channel Capacity and the balance equation: Capacity divided by Toll yields Map (x / ln x ≈ π(x)).

The Meta-Claim

IE does not prove the Riemann Hypothesis, nor does it replace the deep analytic machinery of number theory. But it makes a structural requirement: any persistent information system requires a Governor. Because the primes persist as a coherent informational structure, a stabilizing boundary constraint must exist. The Riemann Hypothesis is simply the Governor that number theory produced.

This reveals something arguably more profound than anything around the Riemann Hypothesis. The integers naturally surface the exact same objects that physical thermodynamics surfaces: channel capacities, Landauer encoding costs, standardized protocols, white-noise margins, and unitary boundaries.

The Birch and Swinnerton-Dyer (BSD)

BSD is another unsolved Millennium Prize problem and is structurally identical to IE’s Entropic Balance Sheet, perfectly equating the continuous thermodynamic drag of an elliptic curve to its discrete hardware capacity and causal waste.

The BSD Entropic Balance Sheet:

• Capacity: The torsion subgroup E(Q_tors): the finite “hardware” of rational points available at the base.

• Map: The algebraic rank r: the compressed dimensionality of the curve’s solution space, measuring how many independent generators exist.

• Protocol: The real period Omega: the transduction interface converting between the continuous analytic side (integration) and the discrete algebraic side (arithmetic).

• Governor: The Tamagawa numbers c_p: local constraints at bad primes that prevent the arithmetic from diverging (the boundary conditions).

• Toll: The central value L(E,1): the irreducible encoding cost of the curve’s arithmetic information at the critical point.

• Margin: The Shafarevich-Tate group Sha(E/Q): the unresolvable cohomological noise, information lost to the ambiguity of principal homogeneous spaces.

Just as the Prime Number Theorem balances x/ln(x) against the zeta zeros, BSD balances the product of these discrete invariants against the analytic drag of the L-function. It is the same ledger, written in the language of schemes rather than channels.

What IE Is and Is Not

IE is built from information theory, control theory, and thermodynamics. These are disciplines typically thought of as grounded in physical reality. Yet here it applies in a platonic realm completely devoid of mass, time, or energy.

IE does not tell you what the Governor is for elliptic curves, only that a Governor must exist if the system persists. It does not derive the specific Toll cost for Alzheimer’s, only that a Toll must exist and can be quantified. And if my particular BSD-to-pillar assignment is incorrect, the framework itself should make the correct one visible.

The fact that all systems that persist have these six pillars unlocks something new when IE is used as a Rosetta Stone.

• Diagnosis: For complex persistent systems that fail (such as Alzheimer’s), rather than reinventing understanding from scratch, identify the pillars and import solutions from domains where failure is cheap to test and well-documented.

• Design: When building new systems, predict the requirements and failure points before they emerge.

• Analysis: Given any existing system, perform a rapid structural audit in a common language. Comparing two companies, two organisms, or two theories becomes structurally identical and easy to compare.

• Translation: When a new field appears (such as AI), instead of reinventing basic concepts, instantly import knowledge from domains that have already solved the same architectural problems.

IE is a Rosetta Stone enables finding solutions to problems in any domain when the same solution has not yet been found in your local domain.

For these two Millennium Prize problems, the remaining work belongs to specialists. What IE contributes is a radically narrower target: RH becomes the problem of identifying the specific operator whose spectrum realizes the Governor (a question Hilbert and Pólya posed a century ago, and which IE suggests is not merely a useful analogy but a structural requirement.¹). BSD becomes the problem of bounding Sha: showing that the Margin is finite and accounting for it explicitly. Neither reformulation is a proof. Both are now actually tractable and solvable unlike the originals.

Why does the fine-structure constant in physics have this approximate value?

To figure out what it is and its exact value we utilize Informational Energetics (IE) to cascade through three systems to the fine-structure constant.

System 0 : The Requirements

Mapping the six IE pillars to the vacuum we determine the three requirements:

• Finiteness: (Capacity, Margin) To prevent energetic and informational divergence.

• Unitarity: (Map, Protocol) To ensure the lossless conservation of information.

• Causality: (Governor, Toll) To enforce a well-defined temporal evolution.

System 1 : The Substrate

System 0’s requirements uniquely constrain a single solution giving us a substrate and the required six pillars:

Substrate: An E8 Manifold split into two D4 dimensions, one of which contains spacetime.

• Capacity: The vacuum has a finite clock: 43 fundamental ticks per cycle, with 32 channels of information per tick. This is the universe's total processing budget, fixed by the geometry.

• Map: To exist as a distinct thing rather than dissolving into the vacuum, a particle needs 5 pieces of information: 3 to say where it is, and 2 to describe the shape of its boundary. Nothing more, nothing less.

• Protocol: Information on this substrate requires exactly 16 bits to propagate without loss, the minimum needed to encode both phase (what a signal is) and handedness (which way it flows). This is why the universe can tell left from right.

• Governor: The boundary of any persistent particle must be a sphere. Only a sphere perfectly separates inside from outside with no ambiguity, and this topological fact is what makes electric charge come in discrete units rather than continuous values.

• Toll: Time itself is the cost of processing and the geometry allocates 11 of the 43 ticks per cycle as overhead, the irreducible slack required for state transitions to complete without destroying information.

• Margin: There is a noise floor below which no signal can persist. The electron sits exactly at this floor: it is the lightest thing that can exist.

System 2 : The Fine-Structure Constant

The substrate presents a natural impedance to sustaining topological structure. This geometric impedance is also a persistent system and contains all six pillars:

where

and results in a value that is only 0.58σ away from the Morel (2020) experimental value:

On this April 1st confirm for yourself by following this link to WolframAlpha and checkout the full derivation in the preprint paper on complex systems that persist: Informational Energetics: A Universal Architecture of Persistence.

Alzheimer’s occurs when the Pathogenic Entropy (Tau/Amyloid) scales faster than the Governor(GSK3β) prevents it and the Protocol (Estrogen/Choline) can regulate it (via the glymphatic system), exacerbated by an exponential rise in Substrate Friction (Fibrosis) that reduces/prevents waste export.

Variable Breakdown

1. The Numerator: Pathogenic Entropy [Kτ​⊗KAβ​]

The Complexity Load: Represents the exponential “coupling” of Tau Tangles and Amyloid Plaques. Structural Noise that prevents the “Model” (ΔI) from communicating with the “Vessel” (ΔE).

INLRP3​ The Accelerant - Neuroinflammation:

• The Concept: Plaques and Tangles are inert trash until the immune system reacts. The NLRP3 Inflammasome is the driver that turns “trash” into “war.” Note this can often be driven by intestinal permeability.

• The Mechanic: When Microglia sense Amyloid, they activate NLRP3, releasing Cytokines (IL-1β, TNF-α). This turns the brain into a scorched-earth war zone, actively killing neurons that might otherwise have survived the plaque load.

• The Multiplier: If Entropy is high but Inflammation is zero, the numerator remains manageable (Asymptomatic AD). If Inflammation spikes,ΨAD goes vertical

2. The Denominator Part A: Governor Control G(Li⋅GSK3β−1)

The Lithium Brake: This is the Governor (G). Lithium inhibits GSK3β, which is the enzyme that “writes” the Tau error. Without Lithium or Estrogen, the Governor fails, and the numerator grows unchecked.

3. The Denominator Part B: Protocol Fidelity MI(ERα⋅PEMT)

The Choline Currency: This is the Signal Fidelity (MI). ERα (Estrogen) activates the PEMT gene to create Phosphatidylcholine. This process is rate-limited by Methylation (B-Vitamins/Homocysteine). This provides the “Bandwidth” for Acetylcholine. If this term drops (as in menopause or APOE4), the system loses its ability to process information.

4. The Denominator Part C: ΩATP​ (Mitochondrial Efficiency):

• The Constraint: Repairing DNA, synthesizing Choline, and exporting waste via the Glymphatic system are all active transport mechanisms. They cost ATP.

• The Failure State: In Insulin Resistance (Type 3 Diabetes), neurons cannot uptake glucose. ΩATP​ approaches zero. As the denominator shrinks, the total equation value (AD Risk) skyrockets.

5. The Exponential Term: Glymphatic Stagnation e(…)

The Friction Coefficient: This represents the Temporal Cost (T).

• Γfibrosis​: The perivascular “clogging” that stops waste removal.

• EPA & Natto: These act as the divisors of friction, keeping the exponential decay in check by ensuring the “pipes” remain open for the sleep-based cleanup cycle via reduction of PAI-1. (Note: the clinical data on Nattokinase penetrating the blood-brain barrier and significantly clearing perivascular fibrosis in humans is still emerging)

  ---

Every Alzheimer’s prevention strategy comes down to balancing this equation.

Crucially, this model defines the velocity of decay. It is highly accurate for Prevention (Stage 0–2). However, for Reversal (Stage 3+), simply balancing the equation is necessary but insufficient. Halting the entropic slide stops the progression, but replacing dead neurons requires a separate “Regeneration Equation” (driven by BDNF and Neurogenesis), which is not modeled here.

While individual biology varies, the core system requirements to stabilize the equation are:

• Regulate Entropy : Inhibit the error-writing enzyme GSK3β (Lithium Orotate) to stop the hyper-phosphorylation of Tau.

• Modulate Input Gain (The Stabilizer): Dampen Hippocampal Hyperexcitability (Levetiracetam/Keppra) to prevent activity-dependent Amyloid generation. High neural “noise” accelerates the production of the numerator.

• Reduce Inflammation: Downregulate the NLRP3 Inflammasome & TNF-α (Curcumin, Fasting/Ketosis) to stop the immune system from attacking the structure.

• Restore Energy: Maximize Metabolic Capacity ΩATP​ (Insulin Sensitivity, MCT Oil/Ketones, Mitochondrial Support) to power the repair systems.

• Signal Fidelity (The Protocol):
  Support the PEMT pathway and membrane integrity (Phosphatidylcholine, Citicoline, improved Estrogen signaling/HRT and ensure adequate Methylation (B-Complex/Folate) to synthesize Choline) to prevent neuronal cannibalization.

• Waste Export (The Flow):
  Reduce Substrate Friction/Fibrosis to maintain Glymphatic clearance (Nattokinase, EPA, Deep Sleep).

If we look at Alzheimer's treatments through the lens of this equation, we see why they keep missing. They are mathematically incomplete. Brand name (Aduhelm / Leqembi, Aricept, Namenda) only solve part of the equation. Current hope (Namenda, GLP-1, Rapamycin, Viagra) also only solve part of the equation. B-Complex (B6/B9/B12) can improve Choline synthesis and HRT can provide estrogen to produce Choline (as long as metabolism is good to allow for estrogen signaling), but they only change Choline. You cannot solve a multi-variable differential equation by changing just one number.

Appendix: APOE gene e4 variant breakdown

This equation shows that APOE4 carriers aren't just "unlucky"; they are Systemically Solvent only when Estrogen is high. Once ERα drops, the Φ term collapses, and because η is already low, the system enters Insolvency (Alzheimer's) almost immediately.

Welcome, and thanks for signing up!

You’ll start receiving new posts right here in your inbox. You can also log into the website to read the full archives or access a clean, ad-free reading experience in the Substack app.

Some housekeeping…

If you can’t find the newsletter, check your Spam folder or Promotions tab, and move this email to your primary inbox.

Get more in the Substack app

We hope you'll take a few minutes to answer our New Reader Survey and help us make Meyer better!

Take Survey

Thanks again, and please tell a few friends if you feel like it.