Examples

The headline is exact — 118,538,803 queries a second, sustained sixteen minutes across 512 shards and 1.22 PiB — and the post spends its first section on what the run did not do: no writes, joins or cross-shard queries, shards primary-only with no replicas, no failover attempted, and an error rate stated to the query (about one in 1.8 million). A developer audience supplies those caveats anyway; printing them yourself is what makes the headline citable instead of a claim to argue with, and it markets a sharded Postgres engine without an adjective.

A vendor benchmark that survives scrutiny because its method is checkable: 100 synthetically generated support tickets in five tonal variants, seven stated usability checks, and cost-per-usable-response reported rather than list price. Publishing the whole spread — the priciest model at roughly 1,446x the cheapest, open-weight medians far below proprietary — is what makes the table citable instead of dismissible, and it markets Neon’s AI Gateway without a single adjective.

The rename (neonctl → neon) is cosmetic; the marketing move is everything around it. Neon assumes the first reader of its interface is a coding agent, gives that reader three focused entry points, and then — the part to steal — writes the exact AGENTS.md snippet it wants developers to paste, down to “run neon checkout <branch> alongside git checkout -b.” Getting named in the file agents read at session start is this cycle’s version of getting into the quickstart, and Neon is the first vendor to just write the entry for you instead of hoping you compose one.

Most outage posts apologize in adjectives. This one prints the uncomfortable specifics: monthly commits went from 1.4B in April to 2.9B in August and the platform failed to scale with them; a client-side retry loop in GitHub’s own Copilot amplified traffic during recovery; and the remediation is stated in checkable quantities — 3M+ CPU cores, 120PB of storage, Azure’s share of platform load moved from 12% in May to roughly 58%. Developers respond because the account is verifiable and self-implicating — naming your own product as part of the cascade is what makes the rest of the post credible. The copyable move: a postmortem is trust content only when it carries the numbers that hurt.

“We moved our docs onto our own platform” is a press release; this post is a ledger. Val Town left Astro and Cloudflare for its own runtime — server- rendered, no build step, edits live in about 100ms — and then names exactly what that costs readers: markdown parsed on the server, CSS concatenated at request time, uncached pages that can take ~500ms. The explicit UX > AX > DX ranking admits the migration optimizes for the builder’s feedback loop, and invites the audience to argue. Copy the shape: if you dogfood in public, publish the column of the ledger that runs against you — it is what makes the other column readable as fact rather than marketing.

The post exists to promote Netlify’s OpenRouter-backed model support in Agent Runners, and it earns the read by doing the thing vendor comparisons almost never do: running the same build prompt three times through 11 models — Claude Opus 5 and Sonnet 5, GPT-5.6, Gemini, Kimi, GLM, DeepSeek — and showing the results including the broken images, the low-contrast pages, and a credit cost that spans 2.4 to 519 for the same task. The uncomfortable conclusion survives publication too: the most expensive model doesn’t reliably win. That honesty is the pitch — the feature being sold is model choice, and the data makes the case for choice better than any adjective could.

The workflow itself is ordinary vendor content: Seer opens PRs for detected issues, Claude routines pick the right engineer and ping them in Slack, action rate rises about 21% and 48-hour response rate about 13%. What earns the read is the third number — PRs closed without merging rose 12.5% — printed alongside the wins and then argued as healthy, because engineers often investigated Seer’s narrow fix and shipped a broader one instead. Seer costs $40 per contributor per month, so this post is doing commercial work; disclosing the metric a skeptic would hunt for is what lets it. Copy the shape: report the delta that hurts, then make the case, in numbers, for why it’s the right trade.

“We run our busiest thing on our own platform” is the oldest proof move in developer marketing, and on its own it’s unfalsifiable. Cloudflare’s version works because the migration hit two of its own published limits — 1,000 subrequests per Worker invocation, 1,024 Workflow steps — and instead of engineering around them internally, the platform teams raised the ceilings for every customer (subrequests now default 10,000, up to 10M on paid plans). The self-reported numbers (9B requests/day, 98.6% cache hit) are the hook; the checkable changelog line is the evidence. Copy the shape: real workload, named friction, shipped public fix.

The headline find is real (three live-format API keys in 27,075 public ChatGPT prompts from the DevGPT dataset), but the tactic is everything around it: the post prints the 1.12% alert rate, admits 48% of alerts came from a single noisy UUID rule, discloses a CredData F1 of 0.449 that beats no one’s marketing copy, and names the limitations it can’t measure. Developers read vendor benchmarks looking for what’s hidden; publishing the noise first removes the thing they’d have dunked on and turns the comment thread into a methods discussion. The whole play is reproducible — the dataset is public — which is what separates it from a claim.

Most VPN marketing waves its hands at “military-grade encryption.” Tailscale does the opposite: one long post walks the whole system bottom to top — the WireGuard tunnels, the NAT-traversal dance, the DERP relays for networks that block UDP. It is the signature-content play. A developer who reads it comes away able to reason about the failure modes, which is exactly the person who then trusts the product enough to run it. Explaining the mechanism is the differentiation, because the competitors won’t.

The docs page is the artifact: it opens with curl https://neon.com/auth.md, the protocol document an agent reads first, then neon claim create --env-pull, and states the whole offer in numbers — 100 MB of storage, 1 GB of transfer, 72 hours, a 15-minute claim code, and credential rotation the moment a claim begins. The move to steal is publishing the unclaimed tier as a pricing line rather than a security policy, and treating the claim as the agent’s activation event: Neon says it chose anonymous registration over an allowlist to see which agents find the file and how far they get.

Launched July 14, 2026, this is the first mass-market platform to treat the agent as a first-class reader and actor. Every docs page is available as markdown, the whole set ships as one /llms-full.txt, and the quickstart’s opening move is handing domains-v3.json to your LLM “so your agent reads the same docs you do.” The part worth copying is the transactional design: registration is quote-then-execute (exact price plus a short-expiry quoteToken), every attempt carries an idempotency key so a retry can’t buy twice, a consent object records which agreements were accepted — and there is no card-number field anywhere in the API. The guardrails are the pitch: they’re what makes delegating a purchase to an agent feel safe.

Stripe’s reference popularised the three-column layout — a stable nav on the left, prose in the middle, runnable code on the right — but the tactic worth stealing is smaller and harder to copy: when you’re logged in, the code samples carry your test API key. There is no gap between reading and running. The skeptic pastes one block and sees a real charge object come back, on their own account, before they’ve decided to trust you. The docs aren’t describing the product; they are the first successful call.

The post turns “our sandbox is secure” — an unquotable adjective — into a checkable market event: up to $1,000,000 in payouts, August 18 to September 1, $50,000 cap for a cross-tenant read, scoped precisely to the Firecracker microVM and network boundary that agents depend on. Developers respond because every element is falsifiable — the scope, the prices, the public program page — and because the framing (“test the boundary before someone else does”) does positioning work whether or not anyone collects. The copyable move: take security work you already fund and give it a date, a number, and a public scoreboard.

Julian Storer — creator of JUCE and the Tracktion DAW — shipped an open-source GUI coding agent built solo over six months and took 276 points and 100+ comments on Hacker News with zero launch budget, in the most saturated devtool category of the year. Every element is the earned-channel playbook: credibility accumulated in public over decades, a repo you can clone and run immediately, no waitlist, no signup, no telemetry, and an AGPL core with an Apache-licensed extension SDK so commercial builders aren’t scared off. The title even leads with the reputation (“by the creator of JUCE”) — the trust shortcut is the headline. If you don’t have a famous founder, the runnable-artifact half of the play still works on its own.

Instead of scattering releases across the calendar, Cloudflare batches them into recurring themed weeks — Developer Week, Birthday Week, Security Week — each a daily drop of real product, mostly free tier. The rhythm does the marketing: developers learn the dates, the press pre-books coverage, and every day compounds the last. It’s the runnable-launch play at an operating cadence — the 2024 inference launch during one such week drove a reported ~15% spike in new developer signups. The format is the moat; a single big-bang launch can’t create the same standing anticipation.

The post states the rule in one sentence — “you only pay when a changeset it generates is merged into your codebase” — and names the industry default it rejects: charging per token, with a fee on top, whether or not anything lands. “A diff is not an outcome; a merged changeset is” is the positioning line, and it turns a pricing decision into an argument about what the agent is for. The honest limit is on the pricing page, not the post: Enterprise starts at $16K a year and “includes credits for AI features”, so the per-merge rate is not public yet, and the model is a sales motion until it is.

Under the price tables the page says “you and your agent can query our pricing data using SQL” and gives a public, read-only Postgres URI with the libpq parameters beside it. A machine reader gets the number as data with a schema, not as prose to parse, and a buyer can answer “what does this cost at volume” with a query rather than a spreadsheet. Two honest limits: the database covers the Postgres and Vitess SKUs only — the new Neki rates sit in the tables above it — and it is a demo of the product as much as a pricing surface, which is exactly why a database company could ship it in a week.

The number is on the page. Supabase separates fixed from usage-based cost, links the meter to a dashboard, and ships a spend cap that’s on by default — the runaway-bill fear that kills usage-based signups is pre-empted before the developer asks. Opacity reads as something to hide; a real price with a cap is itself a trust signal. This is the verifiable-claims play applied to the one page where dev tools most often hide behind “Contact sales.”

Three copyable moves in one artifact. The zero-friction shape — no account, no metered tier, connect the MCP endpoint and go — treats agent-facing discovery as a rail worth owning rather than a product to sell. The context arithmetic is the pitch: Postman claims a brief answers in roughly 27x less context than the official spec it summarises, which is a benchmark a skeptical developer can check. And the brief’s “Not supported:” lines are the sharpest detail — telling the machine reader what an endpoint cannot do prevents the failed integration that would otherwise be blamed on the API.