A post going viral is just a survey with better response rates. Here's what last week's sync engines thread actually taught me. 01 — "Complete" is the enemy of "shipped". My post had 4 tools. The right list had 6+. If I'd waited to get it "right," it never ships. Corrections got me there in 24 hours. 02 — A confident wrong take gets more corrections than a hedged right one. Nobody replies to "here are some tools worth exploring." Everyone replies to "here are the 4 that matter." Use it. 03 — Own the correction publicly. Deleting to avoid embarrassment is the amateur move. Acknowledging what you missed, in a follow-up, builds trust the original never could. 04 — The people who correct you become your best distribution. The ElectricSQL user, the PowerSync team, the callout in replies — they all amplified this week's follow-up. Corrections aren't attacks. They're relationships forming. Every post is a bet: publish incomplete, or publish never. Learning in public means treating your feed as a lab, not a monument. If you're still waiting to have "enough authority" before you post — you're waiting for the wrong signal. Authority is the compound interest of publicly correcting yourself.

6 dev tools that saved me at least a day each this month. Ray.so — code screenshots that ship. Every code snippet in my threads comes from it. Stop mocking editors in Figma. Warp — terminal with AI + shareable workflows. Replaced my zsh + tmux setup. Onboarding new devs got easier. Bruno — API client, local-first, requests are files in your repo. Postman's UX bloat became unbearable. Orbstack — Docker Desktop replacement on Mac. 3× faster boot, 10× less battery. GitButler — virtual branches. Ship 3 features in parallel from one working tree. No more stash-juggling. Raycast + AI extensions — launcher + keyboard LLM. Ask Claude anywhere. Replaced 4 tools I used to keep open. Total monthly cost: ~$40. Total hours saved: too many to count. These aren't hot takes. Just what's on my dock in August 2026. Drop yours in replies — this is how everyone finds the next one.

"Write once, run anywhere" was 2015's lie. In 2026 the pitch is different — and true. What changed: Expo Router is Next.js-shaped for React Native. File-based routes, layouts, server-driven navigation. Same components render native iOS + native Android + web via react-native-web and Metro's web target. EAS + OTA updates ship without app store review. What still breaks: advanced native APIs still need per-platform code (Expo modules soften but don't eliminate). Web bundle size is heavier than a Next.js site — fine for the app shell, wrong for marketing pages. Your design system must be RN-primitive-safe. The 2026 pitch isn't "write once, deploy everywhere". It's "share the boring 70%, native-code the 30% that matters". That's actually true now, and it's the highest-leverage move for any startup shipping to iOS + Android + Web from a small team. If your product ships to all three and you're maintaining three codebases in 2026, you're paying triple headcount for a problem the tooling solved 18 months ago.

The boring stack ships. The exciting one hires consultants. Choose accordingly. Exciting: whatever launched at Next Conf last month. v0.3, breaking changes weekly, docs behind the code. Cool for a side project. Painful for anything with a customer waiting on it. Boring: Next.js on the version before the newest. Postgres, managed. Vercel/Fly/Railway for deploy. Every mid+ frontend engineer already knows it. AGENTS.md is 20 lines. Every team I've seen ship consistently in 2026 uses some variant of the boring stack. Every team stuck rewriting the same feature for the third time picked exciting. The exciting stack is a marketing signal. The boring stack is a shipping signal. Pick which one you actually are. (If you're a technical founder reading this: your first hire should recognize this list on sight. If they need it explained, they're not senior).

Wasm quietly won specific problems in 2026 while the "Wasm-first frameworks" hype died. Here's where it actually wins. Reach for Wasm when:– CPU-bound client work. Image / video / audio processing. FFmpeg.wasm, ImageMagick, canvas filters. 10–100× JS. Figma, Photopea, Runway ship this way. – Local databases. DuckDB-wasm, sqlite-wasm, pglite. Real queries on real data, no server. LiveStore, Observable, Datasette rely on it. – Ported native libs. Cryptography, compression, ML inference, CAD kernels. Bring C/C++/Rust libs into browser reach. Don't reach for Wasm when:– Regular business logic. V8 already optimizes to native speed. You'll pay a 200KB+ runtime cost for functions JS handles fine. – Full apps in Rust / Go / C#. Yew, Leptos, Blazor look cool. Lose on bundle size, DOM interop, and hiring pool. Wasm's role in 2026 is well-defined: heavy compute at the edge of your JS app. Small ports, big wins. Whole-app Wasm frameworks remain a solution looking for a problem.

5 ways AI gets frontend wrong in 2026. If your code review checklist doesn't include these five, agent PRs are shipping bugs past your team. 01 — Trained-on-2023 defaults. useEffect + fetch. Client state that should be RSC. Every model still defaults to pre-2024 React. AGENTS.md forbid list fixes this in one line. 02 — Hallucinated packages. Imports a lib that doesn't exist — or worse, one that got typosquat-registered last week. Verify every AI-suggested dep before install. 03 — Confidently wrong on your conventions. Names collide. Uses class components where you're functional. Same fix — AGENTS.md that spells out house style. 04 — Missed edge cases in state. Happy path works. Loading, error, empty, offline, unauthorized — silently skipped. Ask explicitly for each state or you won't get any. 05 — Passes tests, fails accessibility. Semantic HTML lints clean. Screen reader flow is broken. No linter catches this. Only humans + assistive tech do. Every one of these is a review pattern. Once you know to look, they're fast to catch. Don't ship agent PRs without it.

Last week's post on sync engines had 4 tools. The right list had 6+, plus an abstraction layer I completely missed. Correcting the map — and the frame — in public. The frame I got wrong: "adopt this reactive backend." The frame that's right: "sync engine is a layer choice, not a data-layer commitment." Category 01 — you adopt their data layer: Convex, Zero, Replicache, LiveStore. Category 02 — bring your own Postgres: ElectricSQL (thanks to the person who called this out — TanStack DB is the actual unlock), PowerSync (works web + mobile, not just mobile-first as I framed it). Above all of them: TanStack DB — swap the engine under you without rewriting the app. That last piece changes the risk profile of the whole space. Sync engine as swappable primitive means "wrong pick" is recoverable. In 2024 that wasn't true. Publishing the incomplete take was the right call — the corrections got me from 4 to 6+ in 24 hours. Nobody was going to hand me this map for free.

Onboarding a new dev in 2026 is a different job. If your doc still says "read the README, ship a small feature", you're training 2022 muscle. Day 1. Old: env setup + repo tour with a senior. Half a day lost to Node version fights. New: devcontainer + AGENTS.md read-through. Environment reproducible in one command. AI is their pair from hour one. Day 2–3. Old: "Read this README + Confluence page". Docs stale from 2022. New hire pretends to read them. New: "Ask Claude anything about this repo". Codebase-aware model is their onboarding buddy. Faster than any doc, and never out of date. First PR. Old: "Fix a typo, add a test". Ceremonial. New: "Review 3 agent-generated PRs. Approve or block, with reasoning". Trains judgment from day one — the skill that pays their salary in 2026. The senior task in 2026 isn't teaching people to write code faster. It's teaching them to reject the wrong code faster. Rewrite your onboarding around that and watch time-to-productivity drop from months to weeks.

Local LLMs (Ollama, LM Studio) aren't for everything. Here's when they actually win in your dev loop. Reach for local when it's latency, privacy, or cost: autocomplete on boilerplate (10ms local beats 400ms cloud), commit message + PR body generation, small refactors and renames, regex generation, high-volume repetitive tasks, anything touching NDA data, working offline (planes, cafes, on-call in the wild). Qwen 3, Llama 4, DeepSeek-Coder on a 32GB+ Apple silicon machine are legitimately usable now. Stay on Claude / GPT when it's reasoning, agents, or long context: multi-file refactors, agent runs with tool use, anything needing 200k+ context recall, design conversations, code review on hard bugs, migrations that reason across steps. Anything you'd trust a mid-level engineer with. The gap is closing but not closed. Frontier reasoning is still ~2 years ahead of what fits on your laptop. The 2026 stack isn't "local or cloud." It's both, routed by task. Autocomplete = local. Architecture = Claude. Never the inverse.

Micro-frontends got buried around 2022. Team autonomy came back in 2026 — but the shape is completely different. What died: 2019 Module Federation. Multiple React versions in one shell. Runtime imports of remote bundles. "Everyone can use their own framework." Died from duplicate React trees, version drift blowing up in prod, fragmented a11y and auth, and nobody being able to debug across boundaries. What replaced it: team-owned routes. One framework, one React version. Teams own routes and packages, not runtimes. Turborepo scoping + independent deploys per route via Vercel Fluid. Shared design system enforced through AGENTS.md, not federation. The problem was real — big org, multiple product teams, one product, need for autonomy. The solution just wasn't runtime federation. It was build-time isolation with runtime unification. If your platform team is still evangelizing Module Federation for a new project in 2026, they missed the memo. Suggest Turborepo + route ownership instead and see how fast the conversation ends.

"One senior + AI = a team" is the 2026 slogan. It's true for the code. False for the company. Where it genuinely works: building the first version. Internal tools. Admin panels. Scripts. SaaS with a single well-defined workflow. Content sites, docs, portfolios. Anywhere the surface is small enough that one person can hold it in their head. Where you still need a team: multi-tenant + regulated + on-call. Design system with a design partner. Anything with a real support / customer-success loop. Scaling beyond ~1000 paying users (ops swamp). What AI doesn't cut: sales, support, security review, billing, content ops, account management, deploy tickets. These still scale linearly with customers, and no LLM is closing that gap this year. The solo indie SaaS ceiling in 2026 is genuinely higher than ever. But there's still a ceiling. The devs shipping alone under it are lying to themselves if they think their velocity survives 500 real customers. Ambition ≠ headcount, in either direction.

Where should your docs live in 2026? Four solid picks, one obvious mistake. Mintlify — hosted docs-as-a-service. Beautiful defaults out of the box. Best for API-heavy products and dev-tool companies that don't want to own the site. Priced per editor. Nextra — Next.js + MDX. You own the code, get RSC for free. Best when docs share components with your product or live under your app's domain. Docusaurus — Meta's opinionated framework. Versioning, i18n, plugins. Best for large OSS projects that need per-release doc versions. Mature but heavier than newer options. Astro Starlight — zero-JS by default. Fastest paint of the four. Best for pure content docs. Best signal for AI crawlers — semantic, server-rendered, tiny. The obvious mistake: rolling your own with client-rendered React and hoping crawlers cope. In 2026 docs are read by agents more than humans. Ship server-rendered or ship invisible.

Half your traffic in 2026 is agents — Claude browsing, ChatGPT searching, Perplexity summarizing. Your marketing site was built for the other half. Humans skim visually and leave in 15 seconds. You optimize for hooks, motion, and a fast paint above the fold. Agents read the whole page and often with JS off. They extract structured facts and cite you (or don't) in an answer. What they want from you: semantic HTML, content actually in the HTML (not JS), meta descriptions, JSON-LD, an llms.txt at your root that maps your site. The failure mode is different too. Bad human UX = high bounce. You see the metric, you fix. Bad agent UX = the agent quotes your competitor instead of you. Invisible failure. You never know why the deal walked. If your marketing site in 2026 is a client-rendered SPA, you're invisible to the half of the market that reads through an agent first. Audit yours this week: curl your homepage. If it comes back empty, you have a problem.

Sync engines are the new state management. If you haven't looked at Zero, Replicache, LiveStore, or Convex yet, you're about to. The pitch: "real-time everywhere" without WebSocket boilerplate. Reactive DB queries that just update the UI when the underlying data changes. Optimistic writes with conflict resolution baked in. Zero (Rocicorp) — SQL-shaped apps with 100k+ rows per user. Linear-style. Replaces TanStack Query + manual invalidation. Replicache — mutation-heavy apps with conflict resolution. Notion-style. Client mutations first, server reconciles. LiveStore — local-first + offline mandatory. SQLite in the browser. Note-taking, PWAs, anything you might use on a plane. Convex — greenfield where you own the whole stack. Reactive DB + backend in one product. The watch-out: schema lock-in, vendor-owned runtimes, and a push-model muscle your team hasn't built. Adopt one small feature to a sync engine first before betting the whole app. In 2024 this pitch felt too good. In 2026 it's finally credible. Worth an afternoon of your time this quarter.

Every senior engineer needs a public trail in 2026. Not because you want to be famous. Because AI erased the alternative. Hiring funnel. Invisible senior: recruiter InMail + 6-round loop, prove yourself from scratch. Public senior: warm inbound from people who read you. The interview is a formality. The compensation conversation is different. Influence inside your company. Invisible senior: "convince me in this meeting." Every argument starts from zero. Public senior: "you wrote about this last month — link us." Your public position becomes prior art internally. AI risk mitigation. On paper, "senior engineer" is interchangeable with any other. AI + a resume look the same to the market. Public senior: you have documented taste and judgment AI can't replicate. That's the moat. The bar isn't a following of 100K. You don't need to be famous. You need to be findable, with a track record of judgment someone can verify in five minutes. If someone Googles you today and only finds a LinkedIn, you're one round of layoffs away from indistinguishable. Start writing. Ship weekly. The compounding is invisible for six months, then obvious.

Your dev loop has a monthly bill in 2026. Track it. Then negotiate for reimbursement. Typical senior AI-augmented frontend developer, per month: Cursor / Zed Pro — ~$20 Claude Max — ~$100 API top-ups for agent runs — ~$60 Vercel / Fly / Railway (previews) — ~$40 Copilot as backup — ~$10 Linear / Notion / Figma — ~$30 Sentry / PostHog — ~$20 ~$280 / month, per developer. In 2022 the equivalent was $0. Your subscriptions were free tiers or one-time IDE purchases. If your company reimburses at 2022 rates ("we cover $50/mo of tools"), you're subsidizing your own productivity — and your comp package needs to reflect it. Either negotiate the reimbursement up, or negotiate the base salary up. Both are legitimate. Silent absorption isn't. Write the number down before the next review cycle.

AI made npm typosquatting easier. Every senior team needs a defense minimum in 2026. The 4 threats: 1. AI-hallucinated package names. Model suggests react-select-utils. Attacker registered it last week. You install it. Game over. 2. Compromised maintainers. Popular pkg ships malicious postinstall in a patch. 100M downloads before catch. 3. Transitive drift. Malicious code lives 4 deps deep. Nobody audits there. 4. Postinstall exfil. .env, SSH keys, tokens uploaded during npm install. Nobody notices. The minimum defense: – pnpm audit --prod + Socket.dev on every PR – Pin exact versions. Enable npm provenance in CI. – pnpm --ignore-scripts as default. Allow-list per package. – Verify every AI-suggested import before installing. Download count + last publish date. 10 seconds of check per dep. Your senior job in 2026: no AI-suggested dep lands without a human verifying the source exists and is reputable. The attack surface used to be careless developers. Now it's overtrusting agents.

When to rewrite — and when the "rewrite" is a morale project wearing an engineering costume. Rewrite when: framework EOL, security you can't patch, or the data model is fundamentally wrong. And even then: strangler-fig migration, spec + AGENTS.md before code, page-by-page, feature-flagged, timeboxed. Kill the project if a phase slips 2×. Don't rewrite when: "it's hard to work on" or "too much tech debt". Instead: delete unused code first (usually 20% of the repo). Extract one module, refactor in place. Upgrade framework version by version. Add AGENTS.md so AI writes to your patterns. Fix onboarding docs, not the codebase. If it still needs a rewrite in 6 months, revisit the conversation with more evidence. Most rewrites in 2026 are morale projects. Every one that shipped late killed the team that shipped it. If the reason is "it's hard to hire senior devs into this stack," the answer is AGENTS.md — not a new stack that will be equally hard to hire into in three years.

"Deploy it to the edge" was 2023's cargo cult. Here's the 2026 rule: run functions close to the data they read, not close to the user. Edge (Cloudflare Workers · Vercel Edge · Deno Deploy) — auth checks, geolocation, redirects, A/B splits, header rewrites. Latency-sensitive, stateless, reads from cache or edge KV. Never a DB call. Region (Vercel Fluid · Fly Machines · Lambda in DB region) — RSC data fetch, Server Actions, CRUD, anything touching your primary DB. Anything more than 2 sequential queries belongs here, not at edge. Origin (Railway · Fly · your own boxes) — long-running, WebSockets, uploads, scheduled jobs, queues. Anything that breaks the request-response shape. Serverless will bite you here. The 2024 mistake: putting DB reads at the edge because "edge = fast." You add latency, not save it — every round-trip from Sydney to us-east-1 for a Prisma query costs you 200ms and a rate-limit ticket.

AI does the accessibility checklist. Humans still own the last mile — and every team that forgets this ships broken products. What AI handles well (because Radix + shadcn are its training default): Semantic HTML, aria-* on primitives, focus order, alt text first-pass, contrast checks, landmarks, keyboard nav for common patterns. Linters + axe in CI catch what generation misses. What AI still can't do: Alt text that describes intent, not pixels. Screen-reader flows for complex UI. Knowing when a spinner needs a live region vs when it's noise. Whether an animation crosses the seizure line. Cognitive load in real flows. When "accessible" is not the same as "usable." Testing with actual assistive tech. Delete the a11y ticket that says "run axe and fix". That's automation. Keep the ticket that says "test with a screen reader user". That's the work. Every AI-generated UI I've shipped had 90% of the checklist right and 40% of the experience wrong. The gap is what a senior owns.