← Amplification
Amplification · build

Build This

A small, disposable tool you can build in an evening, and the pattern behind it.

13 issues · 13 pieces · Sep 07 – Nov 15
November 2026
Sunday Full issue →

The Monday Supabase RLS sweep

Effort: ~90 minutes · Runs: weekly, Monday morning

This week's Lovable report is a reminder that the failure is silent: a table without row-level security works perfectly until a stranger reads it. A check that takes one SQL query is exactly what people forget to repeat. A scheduled job that runs the query against every project you own and mails you only when it finds something turns a one-time audit into a standing guard.

THE PATTERN A cheap invariant check, run on a schedule, that reports deltas instead of state. The same shape works for expiring certs, public S3 buckets, or unpinned dependencies.
How to build it
  1. List the Postgres connection strings for each Supabase project you run, stored as read-only credentials in the scheduler's secrets.
  2. For each, run select schemaname, tablename from pg_tables where schemaname = 'public' and rowsecurity = false, and also list tables that have RLS on but zero policies (join pg_policies).
  3. Diff against last week's result stored in a file in the repo, so you hear only about new exposures, and fetch each project's REST URL with the anon key to confirm what an outsider can actually read.
  4. Send yourself one email per run with a subject line that starts with the count, and skip the email entirely when the count is zero.
Wednesday Full issue →

The ownership-sentence A/B

Effort: 30 minutes · Run: once / on demand

Anthropic reports that one sentence moves duplicate-code merging from under 10% of tries to about half, on its own small tasks. Whether that holds on your repo, with your conventions, is a 20-run question a script can answer faster than a week of eyeballing diffs. The point is to get a rate for your code and not an anecdote.

THE PATTERN A vendor-reported prompt effect is a claim about the vendor’s tasks. A paired, repeated run on your own code is cheap, and it applies to any prompt tip you are about to adopt.
How to build it
  1. Pick a small repo, or a branch of one, with two near-identical helpers in it, and write one refactor task prompt that mentions the feature both serve. Commit that as the baseline.
  2. Write a Python script that loops over two conditions (the prompt alone, the prompt plus the ownership sentence) times 10 runs. Each run copies the repo to a temp directory and calls claude -p with the prompt, then saves git diff.
  3. Score each run mechanically: did the two helpers become one (count the function definitions with grep), and do your tests still pass?
  4. Print a table of consolidation rate, test-pass rate and diff size per condition. If the gap is under a few runs, you have your answer: the sentence is not doing much for you.
Sunday Full issue →

The Monday lockfile-versus-advisories digest

Effort: about 90 minutes  ·  Runs: Mondays, 7am

Security news arrives in bulk and almost none of it touches your stack, which is why you skim it and miss the one that does. This task is a good fit for automation because the match is mechanical: your lockfile is a fixed list, advisories are a structured feed, and the only thing worth interrupting you for is the intersection.

THE PATTERN Join a public feed against your own inventory and speak only on a match. The same shape works for competitor changelogs, API deprecation notices and vendor status pages.
How to build it
  1. Commit a small script that reads package-lock.json (or your Python lock and Dockerfile base images) and writes a flat list of name@version.
  2. Have a scheduled Claude routine pull the past week of GitHub security advisories for those ecosystems and keep only entries whose package and affected range match your list.
  3. Add base images as a second pass: note any Alpine, Debian or Node image tags and check them against that week’s OS-level advisories (this week’s musl OpenSSH flaw is the case it would catch).
  4. Send yourself a Gmail digest with one line per match (package, severity, fixed version) and stay silent when the list is empty.
Wednesday Full issue →

The unasked-for agent config audit

Effort: ~25 minutes · Run: once, or on demand after an app update

This week's Postman report is a reminder that a desktop app can add plugins, hooks and MCP servers to your coding agents' config, and a SessionStart hook runs on every session. Nobody reads these files by hand. A script that lists every plugin, hook and MCP endpoint with the date the file last changed takes the guessing out of it.

THE PATTERN Inventory first, judgment second: dump a system's real state into one readable list, then diff it against what you believe is true. It works for cron jobs, git hooks, browser extensions and CI secrets just as well.
How to build it
  1. Start with find: list files modified in the last 30 days under ~/.claude, ~/.codex, ~/.config and ~/.local/bin, plus any .mcp.json in your repos. Paths vary by tool and version, so let find tell you what exists.
  2. Write a short Python script that parses the settings JSON and config TOML it finds and prints three things per file: enabled plugins, hook commands, and MCP server URLs, with the file's mtime beside each.
  3. Save the entries you recognise to an allowlist file and have the script flag everything not on it, in red, with the file path.
  4. Read the flagged hooks first (they execute), remove what you did not add, and rerun after the next Postman, IDE or CLI update.
Sunday Full issue →

The weekly key-spend tripwire

Effort: ~90 minutes · Runs: Mondays at 7am

Leaked AI keys show up first as spend that doesn't match your normal pattern, days before anyone reads a breach notice. Comparing this week's usage per key to its own history is tedious for a person and trivial for a scheduled job, which is why it suits automation.

THE PATTERN Baseline and deviate: store what normal looks like, then let a scheduled job report only departures from it.
How to build it
  1. List every AI provider key your team holds and where it lives (CI secrets, platform env vars, local .env files): provider, owner, location, last rotated.
  2. Each Monday, have a scheduled task pull last week's usage per key from each provider's billing or usage export and append it to a sheet.
  3. Flag any key whose weekly spend exceeds 3x its trailing four-week median, or that shows traffic in hours or regions you don't use.
  4. Email yourself the flags, or “all quiet,” with a link to the rotate runbook so a response takes minutes.
October 2026
Sunday Full issue →

The 90-day compliance clock

Effort: ~90 minutes · Runs: Sundays at 9pm

Policy deadlines are the one category of work risk that gets published well in advance and still surprises everyone, because the publication is a notice on a government site nobody re-reads. The work is pure diff-and-filter: the pages change rarely, the signal is a date, and missing it is expensive and non-recoverable. A person checking ten sources every week quits by week three; a scheduled task does not.

THE PATTERN Hash-then-diff before you spend a token, and make the report distinguish “nothing happened” from “nothing ran.” Any monitor meant to run forever needs a free unchanged path and a heartbeat you'd actually notice going missing.
How to build it
  1. List the sources and keep them as data, not code — the CMS newsroom, healthit.gov/news, the Federal Register API filtered to HHS and ONC, your two largest payers' provider-bulletin pages, and the state boards you bill in. A JSON file in Drive means adding a source never means editing the task.
  2. Fetch each one weekly and store a hash of the extracted text per URL in that same file. Only changed pages go to the model; unchanged pages cost nothing. That cheap unchanged path is what makes it affordable to leave on indefinitely.
  3. For changed pages, pull every explicit date and classify it — effective date, comment deadline, enforcement date, or not a deadline at all. Drop anything past and anything beyond 90 days, which is what keeps the report short enough to read.
  4. Email yourself only the survivors, each as “date — what changes — link”, with a one-line tally on top: “3 new, 2 moved, 11 sources unchanged.” That tally is the whole reliability story.
Sunday Full issue →

The Friday Note-Quality Regression Run

Effort: ~90 minutes · Runs: weekly, Friday 6am

Prompt changes, model deprecations and retrieval tweaks all degrade note quality in ways nobody notices until a clinician complains, because the thing that broke was the fourth-best case rather than the demo case. The fix is boring and nobody does it: freeze a golden set of de-identified transcripts with known-good outputs, run them on a schedule, and score the drift. Make it arrive in your inbox on a Friday morning so a regression has a working day attached to it instead of being discovered on a Monday with a customer on the line.

THE PATTERN Continuous evaluation on a frozen set — the same discipline as a regression test suite, applied to a system whose output is not deterministic, which is exactly why it needs a scheduled run and a threshold rather than a pass/fail. Any pipeline where quality is subjective and the inputs are stable deserves this: coding suggestions, summarization, anything with a prompt in it.
How to build it
  1. Freeze the set — Pull 20–30 de-identified transcripts that cover your real distribution — intake, med management, 45-minute psychotherapy, a crisis note, two with bad audio, one where the clinician talks over the patient. Store them with the current output as the reference, not as a correct answer.
  2. Score three ways — A deterministic layer (required sections present, ICD/CPT codes parse, no hallucinated medication names outside a whitelist), a similarity layer against the reference, and a rubric judged by a model on specificity and omission. Log every score with the model ID, prompt hash and git SHA — without those three the report tells you something changed but not what.
  3. Schedule it — A scheduled task Friday at 6am that runs the set, writes results to a dated row in a Google Sheet, and emails only a diff against last week: every case that moved more than your threshold, with the two outputs side by side. A green week should be three lines long.
  4. Make it fail loudly once — Deliberately break a prompt and confirm the email catches it. An eval harness nobody has seen fire is indistinguishable from one that does not work.
September 2026
Wednesday Full issue →

The timestamp column census

Effort: ~25 minutes · Run: once, or on demand before a timezone-touching change

The Postgres footgun above is not a bug you fix once, it is a class of bug you have an unknown number of. In a behavioral health product the blast radius is visible to the clinician: a session that renders on the wrong calendar day, a note whose service date disagrees with the claim, a "this week" rollup that quietly drops a Sunday. Instead of auditing by memory, generate the finite list once: inventory every temporal column in the schema, grep every place the code does date arithmetic, and join the two.

THE PATTERN Schema census, then grep, then join. Anywhere you have a machine-readable inventory of structure on one side and a greppable pattern on the other, you can turn "we probably have some of these" into a list with a length. It works the same for missing indexes on foreign keys, PHI fields with no encryption annotation, and API routes with no auth decorator.
How to build it
  1. Census the schema — Query information_schema.columns for every column whose data_type is timestamp with time zone, timestamp without time zone, date or time, and write table, column, type and nullability to a CSV. This is your denominator.
  2. Grep the call sites — Ripgrep the repo for AT TIME ZONE, ::timestamp, ::date, date_trunc, now(), CURRENT_DATE, EXTRACT, plus your language’s naive-datetime constructors (datetime.now() with no tz, new Date() arithmetic). Capture file, line and the matched text.
  3. Join and flag — For each hit, resolve which column it touches and flag three patterns: a timestamptz column cast to naive, a date_trunc or interval add with no explicit zone, and any equality comparison spanning both types. Mixed types on either side of an = is the highest-signal flag.
  4. Rank by who sees it — Pipe the flagged list through one model call and have it sort by clinician-visible versus internal-only — note service date, session start, billing period at the top, internal telemetry at the bottom. You are not asking it to find the bugs, only to triage a list you already generated.
Sunday Full issue →

The Coding-Intensity Canary

Effort: ~90 minutes · Runs: Weekly, Monday morning

Blue Cross built its $942 million case out of two numbers pulled from claims: the share of encounters coded as complex, and the count of secondary diagnoses per claim. You can compute the same two numbers on your own output before a payer computes them for you. This is a good automation candidate because the value is entirely in the baseline — a single snapshot tells you nothing, and thirty weeks of snapshots tells you exactly when a prompt change moved your code distribution. It also has to run on a schedule, because the week you'd most want it is the week nobody remembers to look.

THE PATTERN Instrument the metric your critics would use, on your schedule instead of theirs. Any output distribution that could be characterized as drift — code levels, note length, confidence scores, refusal rates, how often a clinician edits the note — deserves a weekly baseline you own. The first time you compute it should not be the first time someone asks you for it.
How to build it
  1. Write one query that buckets last week's generated encounters by code and level — E/M tier, therapy CPT, secondary diagnosis count per encounter — and returns the same buckets for each of the prior four weeks.
  2. Compute week-over-week share deltas per bucket. Flag anything that moved more than two points, and anything whose share is at a four-week high.
  3. Join in the deploy log: which model version, prompt version and pipeline change landed in each week. A shift with candidate causes attached is actionable; a shift on its own is just anxiety.
  4. Schedule it Monday morning, render a short HTML table, email it to yourself and whoever owns coding quality. Persist each week's rollup so the baseline extends instead of resetting.
Wednesday Full issue →

The prompt-cache hit audit

Effort: ~25 minutes · Run: once

Cached input on Opus 5.5 now costs a twentieth of fresh input. That is only a discount if your requests are actually landing on the cache, and almost nobody knows their real hit rate — the usage fields come back on every response and get thrown away. This is a read-only pass over logs you already have, and the answer is either "we're fine" or a specific line of code that moved a variable above the breakpoint.

THE PATTERN when a vendor changes a price, the first move is not to renegotiate or switch — it is to measure which side of the new price your traffic actually falls on. Most systems are already emitting the number that answers it and discarding it on the way past.
How to build it
  1. Pull the last thousand or so model responses out of your logs into a single JSONL file, keeping only the route, the prompt template name, and input_tokens, cache_creation_input_tokens, cache_read_input_tokens.
  2. Twenty lines of Python: hit rate is cache_read / (cache_read + cache_creation + input). Group by route and by template, print a table sorted worst first.
  3. Take the worst group and diff the rendered prompt prefixes of two consecutive calls byte for byte. The culprit is almost always a timestamp, a non-deterministically ordered tool or field list, a session UUID, or a patient-specific header sitting above the cache breakpoint.
  4. Move everything variable below the breakpoint, replay the same day of traffic through a wrapper, and re-run step 2. Write the before/after ratio in the PR description so the next person can tell if it regressed.
Saturday Full issue →

The error digest that ranks by clinicians affected, not by count

Effort: about 90 minutes · Runs: Mondays at 8am

Every error dashboard you have ever used sorts by occurrence count, which reliably puts a retry loop firing forty thousand times a day above the exception that silently broke note generation for eleven people. Count is a property of the code path; what you want is a property of the users. This is worth automating rather than eyeballing because the ranking only becomes obvious once something groups and counts distinct user IDs per error signature, and no human does that on a Monday morning.

THE PATTERN pick the denominator before you build the report. Almost every default dashboard in existence counts events because events are what the system emits, and almost every decision you want to make is about people. Swapping the denominator is usually a one-line change to a GROUP BY and it reorders the entire priority list — which is why it is worth doing deliberately rather than accepting whatever the vendor sorted by.
How to build it
  1. Pull seven days with the user attached — A scheduled task Monday 8am hitting your error tracker's API for the last week. The one field that matters is the user or account identifier on each event; if it isn't there, stop and add it, because everything below depends on it.
  2. Group by signature, count distinct users — Normalise each error to a stable signature (exception type plus the top frame of your own code, not the library's), then count distinct affected accounts and distinct sessions per signature. Plain code, no model.
  3. Let the model write only the "what is this" — For the top ten by users affected, hand it one representative stack trace plus the surrounding source and ask for two sentences: what broke, and the likeliest cause. Never ask it to rank — the ranking is already correct and a model will helpfully ruin it.
  4. Include last week's number — Each row shows affected users this week and last. New and rising is a different email from chronic, and without the delta you will read the same ten lines every Monday and act on none of them.
Sunday Full issue →

The docs-versus-reality diff

Effort: about 2 hours · Runs: Weekly, Thursday morning

Your public docs describe an API that your code has quietly stopped implementing. Every team has this and nobody finds it, because the only person positioned to notice is a new integrator hitting the discrepancy at 11pm, and they file a support ticket instead of a docs bug. It is good automation territory for the boring reason: comparing two structured descriptions of the same thing is mechanical, high-volume and completely unrewarding for a human, and the failure mode of missing one is invisible rather than loud.

THE PATTERN make the model turn unstructured prose into rows, then let deterministic code do the comparison. Everywhere you have a document that is supposed to describe a system — docs against an API, a runbook against a deploy script, a BAA against what you actually retain, an onboarding guide against the current UI — the same two-stage shape applies, and the second stage should never be a model, because a diff that is occasionally wrong is worse than no diff at all.
How to build it
  1. Get ground truth from the machine, not the spec — Hit each documented endpoint in staging with a canned request and record the actual response shape: field names, types, nullability, enum values. A generated OpenAPI file is a second opinion, not the truth; it drifts for the same reasons the docs do.
  2. Extract claims from the docs pages — Fetch each docs URL and pull out every concrete assertion as a row: endpoint, field, stated type, stated default, whether it's called required. Structured rows, one page at a time — do not ask for "what's wrong with these docs."
  3. Diff mechanically, rank by blast radius — Set-difference the two tables. A field the docs promise that no longer exists outranks a new undocumented field, which outranks a wording mismatch. This step is code, not a model.
  4. Send it Thursday, not Friday — One email, ranked, with the docs URL and the observed shape side by side. Thursday leaves a day to fix the two that matter before the week closes.
Monday Full issue →

The clinician objection ledger

Effort: about 90 minutes · Runs: Fridays at 4pm

You already record user calls and demos, and the transcripts already sit in Drive. Nobody re-reads them after the week they happened, so the fourth time a PMHNP says she doesn't trust it with the risk assessment, it lands as one person's opinion rather than as a pattern. That's the shape of task automation is actually good at: there is no judgement call on any single item, only extraction repeated across a corpus too large to hold in your head, plus counting.

THE PATTERN extract structured rows first, aggregate second. Models are unreliable at "what are the themes across these forty documents" and reliable at "pull these four fields out of this one document." So make the model do the narrow thing many times, and let ordinary counting do the reasoning. This generalises to error logs, support tickets, and PR review comments without changing a line of the shape.
How to build it
  1. Point it at the folder — A scheduled task, Fridays at 4pm: read every transcript in the calls folder modified in the last seven days. Nothing clever; the schedule is the feature.
  2. Extract, don't summarise — For each call, emit rows of {objection or request, verbatim quote, speaker role, call date}. Requiring the verbatim quote is what stops the model from melting three distinct complaints into one agreeable paraphrase.
  3. Append, then count separately — Write the rows to one running sheet. In a second pass, read the whole sheet and flag anything raised by three or more distinct clinicians in the last 90 days.
  4. Deliver as email — Send yourself the flagged themes with their quotes attached. A document you have to remember to open is a document you will not open.