Local-First Software
A comprehensive map of local-first software — from foundational philosophy and CRDTs to sync engines, tooling, and real-world production stories.
A comprehensive map of local-first software — from foundational philosophy and CRDTs to sync engines, tooling, and real-world production stories.
The Pragmatic Engineer Podcast • Guest: armin-ronacher
Programming language choice matters more in the AI era, not less — AI code generation quality varies dramatically by target language, and the runtime tradeoffs a language imposes don't disappear just because a machine writes the code.
by alexander-opalic
Not everything that caches locally is local-first. The real test: does the app still work if the company disappears? A categorized directory of real apps across the spectrum.
by indydevdan
Pi agent is the open-source, unopinionated counterweight to Claude Code — minimal defaults, full harness control, and extensibility that lets engineers build what Anthropic won't ship.
by zhanna-sharipova
Owning your data isn't enough — local-first must extend to owning your communication channels, and the same infrastructure that protects human social connections will become the foundation for a trustworthy multi-agent future.
by brooklyn-zelenka
Auth must travel with data in local-first — Keyhive solves this with capability-based certificate chains and a membership CRDT, making the sync server unable to read your data while keeping the UX as boring as a Google Docs share button.
by eileen-wagner
The tech for local-first has matured but the UX hasn't — four unsolved design challenges stand between us and mainstream adoption, and they require collective agreement, not individual solutions.
by adam-fish
Local-first technology only matters if it translates into business outcomes — reliability, speed, revenue. The biggest trap is optimizing for developer fascination instead of real-world impact.
by eduardo-san-martin-morote
Pinia Colada is Vue's answer to TanStack Query — a declarative data-fetching layer built on Pinia that handles caching, deduplication, and optimistic updates so you stop hand-rolling async state management.
by guillaume-chau
A reactive normalized cache for Vue and Nuxt that unifies query caching, cache normalization, optimistic mutations, form handling, and real-time subscriptions behind a pluggable data source architecture — the missing data layer between Pinia and full sync engines.
by conrad-hofmeyr
SQLite in the browser is already production-ready if you pick the right VFS — OPFS with synchronous access handles solved the persistence and sync/async impedance mismatch that held it back for years.
by alexander-opalic
Vue already syncs your refs to the DOM. Sync engines extend that same idea to databases — keeping client state and server state in harmony. Here's how Replicache, Zero, Convex, PowerSync, LiveStore, Jazz, and Dexie each approach this differently.
by aaron-boodman, james-cowling, johannes-schickling, kyle-mathews
Four sync engine builders reveal that the real disagreement isn't sync vs. no-sync—it's where you draw the line between server authority and client autonomy, and every position demands different trade-offs.
by adam-wiggins, martin-kleppmann, aaron-boodman, peter-van-hardenberg
The original local-first essayists and a pragmatic sync-engine builder clash on whether offline writes should ship today or wait for version-control UX — revealing that the real fault line isn't technical but philosophical: who does the tool serve first?
by agenticnotetaking
A Claude Code plugin that generates a complete, personalized knowledge management system through conversation — derivation over templating, backed by 249 interconnected research claims.
by matt-carey
MCP's context bloat problem has a clean solution: give the agent two tools—search and execute—running in a V8 sandbox against the full OpenAPI spec, cutting 1.17M tokens to ~1K.
by christoph-nakazawa
The JS tooling revolution finally delivers on its promise — tsgo, Oxlint, and Oxfmt replace the old guard without compromises, and strict guardrails make LLMs write better code too.
Lenny's Podcast • Guest: boris-cherny
Coding is a solved problem — the bottleneck shifts to taste, product sense, and deciding what to build. Boris Cherny makes the case that underfunding teams, betting on general models, and building for the model six months out is how you win.
by alistair-gray
The competitive moat in coding agents isn't the model — it's the orchestration layer. Stripe's Blueprints prove that mixing deterministic workflows with agentic flexibility, backed by 500 MCP tools, scales autonomous coding to 1,300+ PRs per week.
by indydevdan
Skills alone are a dead end — you need four layers (capability, scale, orchestration, reusability) to solve entire classes of problems with agentic browser automation instead of one-off tasks.
by ray-amjad
Your CLAUDE.md file has a finite instruction budget — stop adding to it and start removing. Every model upgrade should trigger an audit of what to delete, not what to add.
by dwarkesh-patel
Dario Amodei argues we're 1-3 years from a 'country of geniuses in a data center' — but the gap between capability and economic diffusion explains why the world doesn't feel transformed yet.
by goose-oss
Playwright CLI skills let AI agents generate, run, and debug browser tests through natural language — writing snapshots and recordings to disk instead of filling the LLM context.
Lex Fridman Podcast • Guest: peter-steinberger
Fun beats funding — OpenClaw's 180K GitHub stars prove that personality, self-modifying software, and a lobster mascot can outcompete every well-funded AI agent startup that takes itself too seriously.
by andreas-klinger
SaaS is being squeezed from both sides — AI tools let anyone one-shot the core functionality, while enterprise buyers still pay for compounded domain knowledge and trust. The code is worthless; the decisions are the product.
by anthropic
Anthropic's 30+ page official guide covers the full skill lifecycle—from progressive disclosure architecture (frontmatter → SKILL.md → references) through five reusable workflow patterns, three-level testing, and organizational distribution—positioning skills as the knowledge layer that turns MCP's raw tool access into guided, reliable workflows.
by onur-uzunismail
The most effective coding agent isn't the one with the most features — it's the one that wastes the fewest tokens. Pi's radical minimalism exposes how bloated our baseline tools really are.
by asao-takamori, tetsuya-chiba
by rijk-van-zanten
Client-side data management in Vue apps gets exponentially harder once you combine query caching, cache normalization, real-time invalidation, and form mutations—each solved individually by existing tools, but none handling all four together, which motivated building Airstore.
by sarah-perez
Spotify's best engineers stopped writing code entirely — their internal 'Honk' system built on Claude Code lets them ship features from Slack on their phones, signaling that AI coding has crossed from experiment to default workflow at scale.
by steve-yegge
AI's 10x productivity boost creates a value capture war between employers and employees — and without deliberate pushback, the vampire drains everyone. The new workday is 3-4 hours.
by every-inc
Engineering work should make future work easier, not harder—this plugin inverts the technical debt spiral by investing 80% in planning and review so each cycle compounds reusable patterns.
by kieran-klaassen, peter-yang
The simplest form of compound engineering is telling Claude to update CLAUDE.md after every mistake — but the full four-step loop (Plan, Work, Assess, Compound) with specialized sub-agents turns each development cycle into a training run for the next.
by cam-pedersen
The technological singularity is already here—not as machines surpassing human intelligence, but as human institutions and psychology collapsing under the weight of accelerating change they only perceive.
by armin-ronacher
The plummeting cost of code production makes new programming languages viable again—and the winning ones will optimize for machine readability over human brevity.
by simon-willison
AI tools create compulsive task-stacking rather than reducing workload — employees run manual and AI-generated work in parallel, producing exhausting intensity that organizations mistake for productivity.
by margaret-anne-storey
AI accelerates code production faster than human comprehension can follow — the resulting understanding gap is cognitive debt, and it's more dangerous than technical debt because it's invisible until the team hits a wall.
by alistair-gray
Stripe's coding agents produce 1,000+ merged PRs per week by combining isolated devboxes, a customized Goose fork, MCP with 400+ internal tools, and aggressive feedback-left testing — proving that enterprise-scale autonomous coding demands custom infrastructure, not off-the-shelf solutions.
by bryan-finster
AI amplifies existing capability rather than replacing it—developers and organizations with strong engineering foundations gain exponentially while those without see problems compound faster.
by elon-musk, dwarkesh-patel
Earth's flat electricity output cannot keep pace with exponential chip production, making space-based solar the only viable path to scale AI compute — and within 36 months, it will be the cheapest option.
by alexander-opalic
Claude Code's agent teams upgrade the subagent workflow from star topology to mesh — agents can now message each other, coordinate through shared task lists, and collaborate in real time. Three real sessions show the patterns in action.
by moshe-simantov
Documentation indexing for AI agents belongs on the local machine: pre-built SQLite databases eliminate rate limits, cut query latency to sub-10ms, and keep proprietary code queries completely private.
The Pragmatic Engineer Podcast • Guest: grady-booch
Every major abstraction shift in software engineering has triggered the same existential crisis among developers, and each time the industry expanded rather than contracted — the current AI shift is no different.
by alexander-opalic
Nuxt Test Utils v4 requires Vitest v4, a new browser provider package, and careful Vue version alignment to avoid deep DOM type conflicts during typecheck.
by playwright
Playwright CLI saves 4x tokens over MCP by writing browser data to files instead of piping it into the LLM context, making it the better choice for coding agents that can read from disk.
by ray-amjad
Claude Code's new agent teams combine a shared task list with an inter-agent messaging system—two simple primitives that unlock parallel collaboration, persistent teammates, and real-time coordination between sub-agents.
by anton-pidkuiko
An MCP server that gives Claude the ability to generate and render interactive Excalidraw diagrams directly in conversation, turning text prompts into hand-drawn visuals.
by mia-heidenstedt
Developers who treat AI as an autonomous coder lose control of their codebase—effective AI collaboration requires explicit architectural decisions, layered verification systems, and human-written specification tests that resist shortcuts.
by tom-crawshaw
Claude Code's native agent teams replace single-agent sequential work with a lead agent that delegates to parallel teammates, each with their own context window and inter-agent messaging.
by amp
The IDE sidebar is a dead-end interaction model for coding agents—parallel, headless agent swarms that run for 45 minutes without human input replace the one-on-one assistant workflow.
by claire-vo, john-lindquist
Pre-loaded context via mermaid diagrams and automated stop hooks are the two highest-leverage investments senior engineers can make to get reliable output from AI coding tools.
by dev-agrawal
Sync engines collapse distributed state management into straightforward SQL by maintaining local databases that sync bidirectionally, and this architecture extends naturally to AI agents that read and write directly to the database.
by lewis-metcalf
Effective human-agent collaboration requires making problems feedback-loopable: build playgrounds for shared exploration, parameterize experiments for reproducibility, and provide headless CLI tools so agents can iterate in text rather than pixels.
by nicholas-carlini
Sixteen Claude instances working in parallel without human supervision can produce a 100,000-line Rust-based C compiler capable of compiling the Linux kernel—but only when the task verifier and CI pipeline are nearly perfect.
by ryan-lopopolo
When AI agents write all the code, engineering shifts from authoring to harness design—crafting navigable documentation, mechanical enforcement, and feedback loops that keep autonomous agents productive across thousands of pull requests.
by catalin-pit
Slash commands turn repetitive AI prompts into reusable, instantly-triggerable shortcuts—store them once, invoke them forever across Claude Code, Cursor, Gemini, and Codex.
by m-palanikannan
Shipping CRDTs to real users teaches lessons no demo can: save the binary as source of truth, never overwrite—always merge, and build fallbacks for when WebSockets inevitably die.
by karaposu
Vibe-Driven Development transforms intuitive vibe coding into a structured methodology with four pillars—Radical Transparency, Verbose Communication, Explicit Over Implicit, and Human-in-the-Loop—providing repeatable patterns for AI collaboration.
by adam-wiggins
Movements like local-first succeed when idealists define the vision and pragmatists build the infrastructure—neither alone crosses the finish line.
by sunil-pai
Every AI agent framework should be a sync engine—the pull-based architecture agents use today mirrors front-end evolution, and pushing data into agent context solves the fundamental performance problem of MCP tool fetching.
by boris-cherny
Productivity with Claude Code comes from parallel worktrees, plan-first workflows, self-evolving CLAUDE.md files, and skills—multiply your throughput by running more concurrent sessions.
by andrew-milich
Open-source browser games prove you can build complex simulations with vanilla Canvas APIs—no game engine required.
by armin-ronacher
The best coding agents aren't the ones with the most tools—they're the ones that can extend themselves.
by alex-shershebnev
Building AI coding agents requires only basic tooling—a ReAct loop, tool definitions, and MCP integration—and the developer's role shifts from writing code to managing autonomous virtual developers.
by u-other-tune-947
Custom subagents with explicit model assignments and parallel execution now work in VS Code Insiders—conserving 95% of context window by delegating tasks to specialized agents.
by cultrepo
Local-first isn't just offline capability—it's a paradigm shift where data lives on user devices by default, servers become optional infrastructure, and CRDTs enable collaboration without sacrificing ownership.
The Pragmatic Engineer Podcast • Guest: peter-steinberger
Effective agentic coding requires closing the loop—giving AI agents the ability to verify their own work through tests and tooling—while developers shift from writing code to orchestrating parallel agents and designing systems for verifiability.
by anthony-fu
A curated skill collection embeds ecosystem expertise directly into AI coding agents—keeping context synchronized with upstream documentation through git submodules.
by johannes-schickling
Web apps can rival native quality by replacing server-centric data architecture with client-side SQLite and automatic sync engines, eliminating loading states and enabling instant responsiveness
by microsoft
Teaching AI about your codebase through context engineering makes Copilot suggestions more accurate — this hands-on workshop demonstrates the approach using .NET 10 and Blazor.
by michael-bolin
The agent loop—a simple cycle of LLM calls and tool execution—is the core of every AI agent, but performance requires stateless design, prompt caching, and context compaction to avoid quadratic inference costs.
by jude-gao
Embedding documentation directly in AGENTS.md files achieves 100% eval pass rates while skills fail 56% of the time—passive context beats active tool invocation for teaching agents framework knowledge.
by aicodeking
Kimi K2.5 challenges proprietary models at a fraction of the cost: trillion-parameter MoE with vision, agent swarm parallelism, and 5th place on AICodeKing's benchmark—beating Claude Sonnet 4.5 and DeepSeek V3.2.
by jakub-andrzejewski
Vue's `<component :is>` enables config-driven UIs where data structures determine what renders, making interfaces flexible for CMS integration, A/B testing, and white-label products.
by amp
The assistant era is over—agents now write production code. The next frontier is building 'agent-native codebases' with feedback loops that let agents verify their own work autonomously.
by alexander-opalic
A curated learning path for developers who want to master AI-assisted coding, from basic autocomplete to autonomous agents.
by david-ondrej
Remotion's new agent skill lets Claude Code create professional animations by writing React components instead of using complex UI tools—turning video production into a coding problem AI agents already excel at.
by steve-yegge, gene-kim
IDEs and single-agent tools like Claude Code are transitional—the future belongs to swarms of specialized agents, CNC-style automation, and leaders who code their own solutions.
by agentic-ai-foundation
AGENTS.md provides AI coding agents with a predictable location for project-specific guidance, keeping READMEs human-focused while giving agents the detailed context they need.
by github
GitHub's official collection of community-contributed customizations—agents, prompts, instructions, and skills—for extending Copilot's capabilities across domains and workflows.
by kieran-klaassen, trevan
Claude Code's native task system converges with Beads and compound engineering patterns, but the real opportunity lies in contextual intelligence—letting machines query for context rather than forcing artifacts into markdown files.
by simon-willison, wilson-lin
A single engineer armed with 2,000 concurrent AI agents can produce over a million lines of Rust code in a week—FastRender proves linear scaling of coding agents is possible through hierarchical planning and emergent coordination.
by langchain
The /remember command lets agents reflect on conversations and extract reusable knowledge—preferences, workflows, and skills—into persistent storage for future sessions.
by microsoft
Prompt files (.prompt.md) enable reusable, standardized AI workflows that load on demand—unlike custom instructions which apply globally.
by microsoft
VS Code agents handle end-to-end coding tasks across four execution modes: local (interactive), background (CLI), cloud (remote infrastructure), and third-party integrations—with unified session management and seamless handoffs.
by alexander-opalic
Workshop covering the transformation from LLM to Agent, context engineering, AGENTS.md, subagents, and skills in VS Code Copilot.
by ray-amjad
Claude Code's new task system—inspired by Beads—persists tasks to disk with dependency tracking, enabling multi-session orchestration and sub-agent parallelism without context window bloat.
by maggie-appleton
When agents handle code generation at scale, design and architectural planning become the bottleneck—implementation velocity no longer constrains development.
by jeffrey-way
Jeffrey Way declares he's done lamenting AI's disruption to coding—after experiencing layoffs at Laracasts due to AI, he's found more joy programming than ever by embracing agents as pair programmers while maintaining code ownership.
The Diary of a CEO • Guest: benjamin-bikman
Insulin, not calories, is the master regulator of fat storage. Lowering insulin through carbohydrate restriction unlocks fat burning and produces ketones that fuel the brain and heart while eliminating hunger.

Thariq Shihipar
@trq212
We're turning Todos into Tasks in Claude Code. Today, we're upgrading Todos in Claude Code to Tasks. Tasks are a new primitive that help Claude Code track and complete more complicated projects and collaborate on them across multiple sessions or subagents.
by johnson-chu
The fastest JavaScript reactive system achieves its performance through linked-list subscriptions, JIT-friendly monomorphic functions, iterative DFS propagation, and aggressive dependency-list reuse—not clever algorithms but relentless micro-optimization.
by dario-amodei, demis-hassabis
AGI arrives within 1-5 years through AI systems building AI systems—the urgent question isn't whether we'll get there but whether humanity can navigate the technological adolescence of job displacement, geopolitical competition, and autonomous systems without destroying ourselves.
by agentic-lab
Slash commands evolve from saved prompts to full orchestration platforms—most users stop at level one, but level six treats Claude as an architect that spawns specialized subagents with domain skills.
by adam-gospodarczyk
MCP's flaws matter less than the fundamental LLM limitations it exposes: context bloat from tool schemas, degraded instruction following in long conversations, and inference costs that balloon with agentic workflows.
Ryan Dahl
@https://x.com/rough__sea
This has been said a thousand times before, but allow me to add my own voice: the era of humans writing code is over. Disturbing for those of us who identify as SWEs, but no less true. That's not to say SWEs don't have work to do, but writing syntax directly is not it.
by dan-abramov
User-generated social data should behave like files: portable across apps, owned by users, and independent of any single platform.
by hacker-news-community
Simple retrieval often outperforms complex vector infrastructure—BM25, SQLite FTS5, and grep handle most local RAG use cases better than dedicated vector databases.
by blader
A meta-skill that extracts reusable knowledge from debugging sessions and saves it as new skills, giving Claude Code persistent memory across sessions.
by theo-browne
Traditional BaaS platforms like Firebase and Supabase create friction when building with AI—Convex's unified TypeScript backend eliminates the impedance mismatch that slows down AI-assisted development.
by aws
AWS Lambda durable functions let developers write reliable business logic as sequential code while gaining automatic checkpointing, retry handling, and execution suspension—combining monolith simplicity with microservice resilience.
by aws
Lambda durable functions use checkpoint/replay to enable resilient multi-step workflows that can run for up to a year, automatically recovering from failures without re-executing completed work.
by moss-ebeling
Investing in automated feedback mechanisms—build systems, type checkers, visual renderers, formal verification—gives AI agents the ability to self-correct, freeing engineers from manual review.
by alexander-opalic
Learn how to build a conversational AI that queries your personal knowledge base using Nuxt, Nuxt Content, and the Anthropic SDK.
by geoffrey-huntley
Back pressure—automated feedback on quality and correctness—is the key mechanism that enables AI agents to handle complex, long-horizon tasks.
by david-fant
You can extract and reconstruct any React component from a production website by leveraging React Fiber's internal tree structure combined with LLMs.
A collection of notes on AI-assisted coding in VS Code, covering GitHub Copilot, Agent Skills, context engineering, and development environments.
by j178
Pre-commit hooks don't need Python or slow installations—prek delivers the same functionality as a single Rust binary that runs multiple times faster.
Affaan Mustafa
@https://x.com/affaanmustafa
The Shorthand Guide to Everything Claude Code. Here's my complete setup after 10 months of daily use: skills, hooks, subagents, MCPs, plugins, and what actually works. Been an avid Claude Code user since the experimental rollout in Feb, and won the Anthropic x Forum Ventures hackathon with Zenith alongside @DRodriguezFX completely using Claude Code.
by mattpocockuk, dex-horthy
Live conversation exploring practical approaches to AI-assisted coding, context engineering, and building reliable agents in complex codebases.
by mattpocockuk
AI coding agents working autonomously need feedback loops to verify their own work—TypeScript for type errors, Vitest for logic bugs, and Husky to enforce both before every commit.
by onmax
Portable AI skills bring Nuxt, Vue, and NuxtHub expertise to coding assistants—skills activate based on file context, making agents domain-aware without manual prompting.
Doppelgänger Tech Talk
Massive AI funding rounds (Replit $9B, Parloa $3B), Aleph Alpha's founder departure signals German AI troubles, while DeepSeek's hedge fund origin reveals a 57% return story behind the AI disruption.
by anthropic
AI's productivity gains shrink dramatically when you account for task reliability—Anthropic's new 'economic primitives' reveal that complex tasks show greater speedup but lower success rates, and AI disproportionately affects higher-skilled work.
by joao-moreno
A client-side search engine built entirely in Rust and WebAssembly can deliver sub-millisecond queries without external dependencies—Copilot made the unfamiliar stack approachable.
by github
Build AI coding assistants by connecting to Copilot CLI through JSON-RPC, letting you embed GitHub's coding agent into any application.
by cynthia-dunlop
Publishing imperfect work beats endless revision—lowering your standards is the key to consistent technical blogging that builds career opportunities and professional influence.
by amp
Tab completion is obsolete because AI agents now write most code—the human-as-coder premise that autocomplete was built on no longer holds.
by geoffrey-huntley
Coding agents are just 300 lines of code running in a loop—demystifying AI tooling reveals that the model does the heavy lifting, and understanding these primitives transforms you from AI consumer to AI producer.
by artem-zhutov
The real differentiator for Claude Code mastery isn't more tools or skills—it's building feedback loops that analyze your own conversations for friction points and storing all your personal context where the agent can act on it.
by jens-neuse
Good GraphQL schemas start from client needs, not backend models. Ten principles—from capability-based design to organizational alignment—establish patterns for maintainable, evolvable APIs.
by william-lyon
Enterprise AI value is shifting from systems of record to decision traces — graph databases that capture not just what happened, but why, creating an institutional memory that makes AI recommendations auditable and precedent-aware.
by shu-ding, andrew-qu
Performance problems compound over time, so optimization work should follow a strict priority order: eliminate waterfalls first, reduce bundle size second, then progressively address server-side, client-side, and re-render issues.
by nick-randolph, geoffrey-huntley
Companies consume open source freely while holding unpaid maintainers to impossible SLAs—the solution is treating open source as critical infrastructure that requires active contribution, not just consumption.
by visual-studio-code
Dev containers provide isolated, reproducible development environments that let you run AI coding agents safely separated from your local machine, with instant portability between local Docker and GitHub Codespaces.
by daniel-roe
Effort has intrinsic value—AI should amplify human agency, not replace it. Shortcuts that bypass genuine work produce hollow achievements and sacrifice skill development.
by vishwas-gopinath
CLAUDE.md files persist project-specific instructions across Claude sessions, eliminating repetitive context-setting and maximizing setup leverage.
by teltam
AI models can handle routine tasks, but developers must retain ownership of critical thinking—effective Claude Code usage requires intentional context management, strategic prompting, and robust testing infrastructure.
by geoffrey-huntley
Understanding how coding agents work—tool calls, inferencing loops, the basic primitives—is now baseline knowledge for software engineering interviews, not optional curiosity.
by steven-chambers
At Netflix's scale of 160 million resolver executions per second, even innocuous framework code can become a critical bottleneck. Doubling fleet efficiency came from fixing a simple introspection API call.
by indydevdan
Thread-based engineering provides a mental framework for measuring improvement with AI agents—scale by running more threads, longer threads, thicker threads, and fewer human checkpoints.
by simon-willison
Claude Cowork repackages Claude Code's powerful agentic capabilities for general audiences through accessible design rather than technical innovation—a pragmatic approach to unlock untapped value.
by leigh-griffin, ray-carroll
Specifications become the authoritative source of truth in software systems, with implementations continuously derived and validated against them—a paradigm shift that trades code-centric development for declarative intent.
by anthropic
Official documentation on Skills—markdown files that extend Claude Code with specialized knowledge and workflows, triggered automatically based on semantic matching.
Normalized Distance from Main Sequence (D) identifies structurally poor code by measuring how far components deviate from the ideal balance of abstractness and stability—making it the single best metric for detecting AI-generated code that compiles but rots.
The Diary of a CEO • Guest: anna-lembke
Our brains evolved for scarcity but now live in abundance, making us all vulnerable to addiction. The relentless pursuit of pleasure leads to anhedonia—the inability to experience joy.
by neal-ford
MCP enables enterprise architects to express architectural intent without implementation details, solving the brittleness problem that has plagued fitness function governance at scale.
by lachlan-miller
Pure functions that receive arguments and return new values (functional core) should handle business logic, while a thin imperative shell manages state mutation and UI integration.
by mario-bittencourt
Business logic belongs in pure functions (functional core) while infrastructure concerns like databases and UIs live in the imperative shell—and the core must never call the shell.
by geoffrey-huntley
A hands-on Go workshop that builds a coding agent incrementally through six files, each adding one capability - proving agents need only simple primitives composed in a loop.
The Ralph Wiggum technique: a bash loop that runs AI agents autonomously, resetting context each iteration to stay in the 'smart zone'
by geoffrey-huntley
Software development now costs $10.42/hour when running Ralph loops—the key is deterministically malicking the array, starting with a screwdriver before grabbing the jackhammer.
by covibes
Multi-agent validation prevents self-deception in autonomous coding—the validator didn't write the code, so it can't lie about tests.
by tatsuya-yoshihara
Denji encounters a mysterious girl named Reze who turns his chaotic devil-hunting life upside down in this explosive sequel to the acclaimed anime series.
by peter-steinberger
A self-hosted Claude-powered assistant that runs across messaging platforms like WhatsApp, Telegram, and Slack—turning natural language into automated workflows for email, calendars, and home automation.
by kit-langton
Effect Institute offers structured courses for mastering Effect, the TypeScript library that brings type-safe error handling, concurrency, and functional patterns to production applications.
by dave-aronson
Code coverage tells you what code runs—mutation testing tells you if your tests would actually catch bugs by deliberately breaking code and checking whether tests fail.
by simon-de-lang
Code coverage measures what runs, but mutation testing reveals whether your tests actually catch bugs by deliberately breaking code and checking if tests fail.
by alexander-opalic
Weekly Vue ecosystem digest
by alexander-opalic
Vue 3.6 beta with Vapor Mode, Vite 8 with Rolldown bundler, Nuxt Studio goes free and open-source, and Nuxt 3 EOL in 3 weeks.
by alexander-opalic
Vue 3.6.0-beta.2 brings Vapor Mode to beta, NuxtLabs joins Vercel making Nuxt Studio free, and Nuxt 3.16 delivers 32% faster loading.
by worldofai
Claude Code 2.1 ships a massive feature set—skill hot-reloading, forked sub-agents, Chrome browser integration, LSP support, and async agents transform the terminal into a multi-threaded agent orchestration platform.
by alexander-opalic
Claude Code 2.1 collapses the distinction between skills, slash commands, and subagents—skills can now fork into isolated contexts and specify their own model, making them the single abstraction for agent orchestration.
by alexander-opalic
Claude Code 2.1 transforms skills from specialized knowledge containers into a unified automation abstraction—hot-reloading, forked contexts, lifecycle hooks, and agent specification make skills the default choice for extending Claude Code.
by dmytro-krasun
Understanding browser internals—from URL to pixels—builds the mental model every web developer needs to debug performance issues and write faster code.
by anil-dash
The most successful technology standards emerge not from corporate control but from individual creators solving genuine problems and freely sharing solutions—as Markdown's journey from blogging tool to AI infrastructure demonstrates.
by marty-cagan
The job of a product manager is to discover products that are valuable, usable, and feasible—not to manage projects or gather requirements.
by visual-studio-code
Agent Skills are portable instruction folders that load on demand, transforming AI agents from general assistants into domain-specific experts through scripts, examples, and specialized workflows.
by nate-b-jones
AI loops can now automate classification, routing, and surfacing of thoughts without user effort—making 2026 the first year non-engineers can build reliable second brain systems.
Jarrod Watts
@https://x.com/jarrodwatts
here's the prompt it uses under the hood for those curious

Geoffrey Huntley
@geoffreyhuntley
we need to strip 40 years of computing dogma and the depth to which we need to do this will scare many people. we are still engineers but now we got this magic space dust that enables us to reimagine the new machine. @leodido gets it and he's on another dimension as to how far we need to cut lovely catching up you again dude!
by drew-breunig
Specification-only libraries work for simple utilities but foundational software still requires actual code, community oversight, and sustained maintenance.
by simon-willison
Reasoning models have made LLM-generated code undeniably good, and 2026 will bring both a major security incident from coding agents and the resolution of the sandboxing problem.
Yash Bhardwaj
@https://x.com/ybhrdwj
Tailwind lays off 75% of their team. The reason is so ironic: their CSS framework became extremely popular with AI coding agents (75m downloads/mo), meaning nobody would visit their docs where they promoted paid offerings, resulting in 40% drop in traffic & 80% revenue loss.
Steph Ango
@kepano
Some seem to interpret this as meaning I'm anti-internet? I'm not. That's silly. My point is pro-interoperability. Interoperability has been so suppressed over the last two decades that it's limiting how people think about what computers can do, and what the design space for local software looks like. A limitation of cloud apps is that you have to interact with the interface you're given. Some cloud apps have APIs that developers can use to access that data with other tools but it's always an abstraction that requires some skill. If you switch from a cloud app to using local files you're effectively switching from a single tool to a constellation of tools that can all directly work with the same data. The problem I see is that many people who switch to local files impose on themselves the limitations of a cloud app. This is because we have become so accustomed to those tools and their limitations. An example: some people seem to think Obsidian should be an all-in-one tool and implement every feature under the sun. I think that would go against what makes it special. Remember the idea of skeuomorphism: "A skeuomorph is a derivative object that retains ornamental design cues (attributes) from structures that were necessary in the original." If you're exploring the idea of "file over app" you have to adopt its native qualities and avoid thinking skeuomorphically.
by alexander-opalic
A future vision where AI, robotics, and exponential technologies create unprecedented prosperity, making goods and services widely available at low cost, potentially leading to universal high income rather than just basic income.
by chase-adams
A structured Obsidian vault with numeric folder prefixes, tag taxonomies, and Claude Code integration transforms a note-taking app into a holistic life operating system.
by terence-tao
The breakthrough in AI-assisted mathematics isn't just solving problems—it's the emerging capability to rapidly write and rewrite expositions of solutions.
by zeframlou
A Claude Code plugin that phones you when the AI finishes a task, gets stuck, or needs a decision—enabling true asynchronous collaboration without constant monitoring.
by kenji-iwaisawa
Gifted runner Togashi dominates 100m races until transfer student Komiya arrives, motivating him to train harder. A philosophical exploration of what drives us to compete.
by humanlayer-team
Systematic context management—through frequent intentional compaction and a Research-Plan-Implement workflow—enables productive AI-assisted development in complex production codebases.
by antonio-erdeljac
A complete project walkthrough for building a Cursor-like AI code editor using Next.js 16, React, and Convex as the backend—demonstrating how to combine modern web technologies with AI capabilities.
by tkdodo
Compound components work best for flexible layouts, not dynamic data or fixed structures. A factory function pattern solves the type safety problem without sacrificing flexibility.
by indydevdan
PreToolUse hooks provide defense-in-depth protection for Claude Code by intercepting tool calls before execution—blocking dangerous commands and protecting sensitive files.
by indydevdan
AI coding agents can execute destructive commands autonomously. Without guardrails like permission prompts, sandboxing, and careful workflow design, Claude Code's power becomes a liability.
by langchain
Context engineering—filling the context window with the right information at each step—determines agent performance more than model choice or complex frameworks.
by geoffrey-huntley
AI's perceived ineffectiveness stems from insufficient deliberate practice, not fundamental limitations—mastery requires the same intentional experimentation as learning a musical instrument.
by jediah-katz
Coding agents perform better when they pull context on demand rather than receiving everything upfront—files serve as a simple, future-proof abstraction for this dynamic retrieval.
by joseph-kosinski
A washed-up F1 prodigy returns to racing thirty years after a career-ending crash, proving that second chances—and vintage cool—still exist in a sport obsessed with youth.
by paul-hammond
Code coverage lies about test quality—mutation testing exposes weak tests by asking 'if I introduced a bug here, would my tests catch it?'
by nuxt
Real-time accessibility auditing inside Nuxt DevTools catches WCAG violations during development rather than after deployment.
by ryan-carson, geoffrey-huntley
Ralph ships code while you sleep—a bash loop that pipes prompts into your AI agent, picks tasks from a JSON backlog, runs tests, commits passing code, and repeats until done.
by ryan-carson
Ralph solves the context window limitation by breaking work into independent iterations—each Amp session gets a fresh context, implements one story, and commits before the next iteration begins.
by repomirrorhq
Running Claude Code in headless loops can port entire codebases overnight—the key is simple prompts, one goal per iteration, and letting agents self-terminate when stuck.
by developers-digest
Claude Code can become a self-correcting system by capturing mistakes in CLAUDE.md—each error becomes a permanent lesson that compounds over time.
Jarrod Watts
@https://x.com/jarrodwatts
a practical guide to context engineering "ai slop" is no longer the fault of the model, but the fault of the user. in black box systems like claude code, context is the single input we can control - so how do we optimize it?
by dex-horthy
The Ralph Wiggum Technique evolved from a novel idea to a mainstream development methodology in under a year—early adopters learned that poor specs doom loops and iteration beats over-planning.
by matt-wonlaw
CRDTs let replicas update independently and merge automatically without conflicts
by thariq-shihipar
Bash is the most powerful agent tool. The Claude Agent SDK packages Claude Code's battle-tested patterns—tools, file system, skills, sandboxing—for building coding and non-coding agents alike.
by alexander-opalic
How I added Excalidraw diagram support to my Nuxt site, including failed attempts at build-time SVG conversion and the simpler solution using Obsidian's auto-export.
by nikita-prokopov
Adding icons to every menu item defeats their purpose—differentiation requires scarcity, and when everything has an icon, nothing stands out.
by johannes-schickling
A client-centric state management framework combining reactive SQLite with event sourcing and built-in sync, designed for high-performance local-first applications
by burke-holland
AI coding agents can replace developers for many tasks—Claude Opus 4.5's self-correction capabilities make human code review increasingly optional.
by geoffrey-huntley, dex-horthy
The official Anthropic Ralph plugin differs fundamentally from the original technique: outer orchestrators with full context resets produce deterministic outcomes, while inner-loop plugins with auto-compaction lose critical context.
by alexander-opalic
Ralph is a bash loop that feeds prompts to AI coding agents repeatedly—the key is one goal per context window, deliberate context allocation, and robust feedback loops.
by christina-marfice
Speed is Superhuman's core feature. Every interaction under 100ms feels instantaneous, and the product achieves this through local caching, preloading, and keyboard-first design.
by philipp-schmid
As AI models converge in benchmark performance, the infrastructure managing them—Agent Harnesses—becomes the competitive differentiator for building reliable, multi-day workflows.
by u-similar-bid1784
Production-quality vibe coding requires strict CI/CD pipelines, git discipline, extensive planning, and expert oversight—code is 30% of the work, deployment and performance are the real challenges.

Matt Pocock
@mattpocockuk
My Ralph Wiggum breakdown went viral. It's a keep-it-simple-stupid approach to AI coding that lets you ship while you sleep. So here's a full explanation, example code, and demo.
Carl Assmann
@https://x.com/ccssmnn
here's the opencode session i used to create a detailed plan for a workspaces feature in alkalye.com. i first described what was on my mind and then had it interview me for details. then i gave it matts post to generate a bash script and a prd file based on the plan. let it run over night and now have this PR to review with 60 commits and 5k new lines of code
by andy-pavlo
PostgreSQL dominated 2025 through major acquisitions, while MCP standardized LLM-database integration and file format fragmentation continued despite Parquet's ubiquity.
The Pragmatic Engineer Podcast
Chip Huyen explains how AI engineering differs from ML engineering, walking through the practical developmental path from prompts to RAG to fine-tuning.
by chip-huyen
A practitioner's guide to building applications on foundation models, covering prompt engineering, RAG, finetuning, agents, and evaluation.
by trey-grainger, doug-turnbull, max-irwin
The holy grail for AI-powered search lies at the intersection of semantic search, personalized search, and domain-aware recommendations—systems that understand the domain, the user, and can match arbitrary queries to any content.
by carl-assmann
A local-first markdown editor PWA with E2E encryption, collaborative editing, and presentation mode.
by tiago-forte
A methodology for capturing, organizing, and retrieving digital information using the CODE framework and PARA organization system.
Resources for mastering Claude Code - from daily tips to advanced customization
by sarah-drasner
A practical guide to engineering management focused on empathy, trust, and supporting your team—written for those who didn't plan to become managers.
by steve-fenton
A comprehensive guide to GitHub Actions covering architecture, core components, best practices, and practical implementation patterns.
Patterns and tools for building GraphQL APIs—from schema design to Meta's fragment philosophy
by rami-mccarthy, shay-berkovich
A comprehensive security guide covering organization-level configuration, workflow hardening, and self-hosted runner protection for GitHub Actions.
by maggie-appleton
Language models will enable a new class of 'barefoot developers'—technically savvy non-programmers who build small-scale, personal software for their communities, and local-first should position itself as the default infrastructure before cloud platforms lock them in.
by gergely-orosz, martin-fowler
Martin Fowler argues AI represents the biggest shift in software engineering since assembly to high-level languages—not because of abstraction level, but because we now work with non-deterministic systems.
by karlos
A walkthrough of Steph Ango's minimalist note-taking system in Obsidian, emphasizing flat folder structures, heavy linking, and properties over hierarchy.
by david-greenspan
A technique for maintaining ordered sequences in collaborative systems using string-based keys that allow arbitrary insertions without renumbering.
by peter-van-hardenberg
Ink & Switch's three-part vision: local-first software enables universal version control, which enables malleable software — and the philosophical endgame is turning people from app buyers into tool users.
by viktor-e-frankl
A Holocaust survivor's memoir that argues the primary human drive is not pleasure but the pursuit of meaning.
by productdevbook
A Nitro module that adds GraphQL servers with automatic schema discovery, type generation, and zero-config defaults. Supports GraphQL Yoga and Apollo Server.
by darin-suthapong
Obsidian Base is a single-vault database for filtering and viewing notes by properties, bridging reflection and action-oriented workflows.
by marcus-felling
Practical techniques to speed up GitHub Actions workflows through caching, parallelization, matrix builds, and conditional execution.
by chip-huyen
A comprehensive guide explaining the three-phase process (pretraining, supervised fine-tuning, RLHF) used to train models like ChatGPT.
by martin-kleppmann
Martin Kleppmann traces local-first from CRDTs to a proposed definition: software where another computer's availability never blocks the user—including when the developer shuts down.
by vladimir-sheremet
Vitest 3 standardized APIs and improved browser mode; Vitest 4 rewrites mocking, adds visual regression testing, Playwright traces, and VS Code debugging.
by zsolt-viczian
Zsolt Viczián demonstrates his new Mind Map Builder script for Obsidian Excalidraw, enabling rapid visual thinking with keyboard navigation, markdown interoperability, and flexible layout controls.
by strangest-loop
Genuine accomplishment requires direct action—preparation, planning, and talking about goals are not substitutes for execution.
by tuomas-artman
Beyond performance and offline support, local-first architecture dramatically improves developer productivity by eliminating network error handling and enabling synchronous data access.
by aicodeking
Vibe Kanban is an open-source tool that lets you orchestrate multiple AI coding agents from a visual Kanban board, treating coding tasks as asynchronous jobs rather than blocking conversations.
by mohammad-bagher-abiyat
Vitest Browser Mode runs tests in real browsers instead of jsdom simulations, eliminating false positives from Node.js APIs leaking into the test environment.
by jessica-sachs
Vitest browser mode runs component tests in real browsers instead of JSDOM, providing actual rendering confidence while maintaining Vitest's speed and developer experience.
by stephen-wolfram
Explains how ChatGPT works by breaking down neural networks, embeddings, and training—connecting modern AI to foundational questions about language and thought.
by cian-clarke
BMAD's spec-driven methodology beats pure prompting for production-ready AI development because it forces clarity before code and catches requirements gaps before they become technical debt.

Michael Thiessen
@MichaelThiessen
Is it just me? My entire timeline is filled with AI coding tweets, nothing about specific tech or any actual code like there used to be. Maybe the algorithm put me in a bubble here…
Machina
@https://x.com/EXM7777
how to tweet 8 months ago i'd never written a single tweet in my life. today my DMs are full of people messaging me about my content... not just because it's valuable but because of how it's written. what i'm about to break down won't work for absolutely everyone, but it works for most people trying to build an audience that generates real business. there are tons of ways to grow on this platform, my strategy is simple: post a shit ton of high-value content every single day. first thing you need to know: a brilliant insight doesn't automatically turn into a great tweet. i still post incredibly valuable stuff that completely flops because my writing wasn't tight or the algorithm decided to ignore it that day. so what actually matters when you sit down to write? > it needs to be genuinely valuable this sounds painfully obvious but you can't just regurgitate advice that's been floating around for years. i see the same recycled tips everywhere... stuff said a thousand times and it won't make anyone stop scrolling. you need to dig into your experience and pull out insights that are fresh. things that haven't been beaten to death across the platform. ideas that could genuinely shift how someone approaches their work or thinks about their business. the difference between content that gets ignored and content that gets saved is whether you're saying something new or at least saying something old in a way that makes people see it differently. ask yourself before posting: would i bookmark this if someone else wrote it? if the answer is no, keep working on it. > it needs to be immediately actionable an insight without a blueprint is basically entertainment, not education. i see tweets constantly like "wow this new ChatGPT update is absolutely insane" with zero context or application. maybe it gets views if you're lucky... but it brings in almost no followers and definitely zero business opportunities. people don't follow you because you noticed something, they follow you because you taught them how to use it. so if you're writing about that ChatGPT update, don't just point at it. write "how to write copy that sounds human with GPT-5.2:" and then walk through the actual process. step by step, line by line, exactly how to implement it in their workflow. people will read the entire thing because you're not just giving them information, you're giving them a system. do this consistently and some percentage of your followers will want to hire you because they've already seen proof you know what you're talking about. the tweets become your portfolio. > it needs to spark natural engagement this is where most people mess up because they think engagement means begging for it. "like if you agree" or "retweet this if you found it helpful" just makes you look desperate. you want your tweet structured in a way that naturally creates replies and bookmarks without asking. bookmarks happen automatically when your hook uses phrases like "here's how" or "how to" or "do this" because you have maybe one second to stop someone mid-scroll and a ton of people operate on autopilot... they see something that looks useful, bookmark it for later, keep scrolling. for replies, you've got two main approaches: - push your opinion harder and take a clear controversial stance - keep it slightly open and invite perspective both strategies work, you just need to pick which one fits the content better. > it needs to be ridiculously easy to read this seems super basic but it's the difference between someone reading your whole tweet or bouncing in half a second. most people scroll through their feed at insane speeds, their eyes land on your tweet for maybe one second before deciding whether to engage. your hook needs to be short and punchy, ideally one line that clearly signals what value you're about to deliver. "how to X" or "why X doesn't work" or "the X mistake you're making" after that, use one sentence per line whenever possible. this creates natural rhythm and makes everything way easier to process visually. throw in lists using "-" or ">" or "1." to organize complex information into digestible pieces. white space matters. the space between your lines and sections gives people's eyes a place to rest. simplify everything as much as you possibly can. aim for a conversational tone like you're a mentor talking to students. use "use" instead of "utilize". say "help" instead of "facilitate". write "get better" instead of "optimize performance". if your 14-year-old cousin couldn't understand your tweet, it's probably too complex. > you need to develop your own recognizable style when i scroll through my feed i see the exact same content written in the exact same style everywhere. same hooks, same structure, same voice. it all blends together into this generic AI-sounding content soup. but when someone has a writing style i can identify instantly, a structure that screams "this is them"... i stop scrolling completely. your style is what makes people remember you. maybe you always use ">" to break down processes. maybe you start most tweets with a specific pattern. maybe you write in fragments sometimes for emphasis. these little patterns become your signature, and people start recognizing your tweets before they even see your name. the key is consistency without being formulaic. and when you nail all of this consistently... you build an audience that respects your ideas, not just your follower count.
by ado-kukic
A comprehensive guide compiling 31 daily Claude Code tips, progressing from foundational concepts to advanced patterns like subagents, skills, and SDK usage.
The Diary of a CEO • Guest: tristan-harris
Tristan Harris warns that AI companies are racing to build a 'digital god' that could automate all human cognitive labor, with insiders believing this will happen within 2-10 years while publicly downplaying the risks.
by matt-mahoney
Meta's @async directive solves the problem of paying server compute costs for data that may never be displayed, using a persist-time transform that defers fragments until explicitly requested.
by ryan-peterman, boris-cherny
Boris Cherny, creator of Claude Code and former Meta principal engineer, shares how side projects, generalist thinking, and cross-org navigation shaped his career—plus insights on how AI tools are reshaping engineering productivity.
by neal-ford, rebecca-parsons, patrick-kua
A framework for designing software architectures that evolve over time, using fitness functions to protect important characteristics while enabling incremental change.
by neal-ford
Evolutionary architecture supports guided incremental change through fitness functions—automated tests that validate architecture characteristics like performance, security, and structural integrity.
by alexander-opalic
Set up desktop notifications for Claude Code using hooks to get alerted when Claude needs permission or input—no more terminal watching.
by fernando-rojo
Replace boolean prop sprawl with compound components. Lift state to context providers and compose distinct component trees instead of branching with conditionals.
by andrej-karpathy
A comprehensive introduction to how large language models work, covering the entire pipeline from internet data collection through tokenization, neural network training, and inference.
Lex Fridman Podcast
DHH shares his unconventional path to programming, defends the simplicity of 90s web development, explains Rails 8's 'no build' philosophy, and argues against treating open source as a crisis requiring more funding.
by john-maynard-keynes
Keynes' 1930 essay predicting that by 2030, technological progress would raise living standards 8x and reduce the workweek to 15 hours—freeing humanity from 'the economic problem' but raising new questions about purpose.
by steph-ango
Evergreen notes decompose complex ideas into atomic, titled concepts that become objects you can manipulate, combine, and stack—without holding them all in your head.
by mo-gawdat, steven-bartlett
Mo Gawdat, former Chief Business Officer at Google X, warns that AI represents humanity's greatest existential challenge—bigger than climate change—and outlines his 'three inevitables' for why we're approaching a point of no return.
by benjie-gillam
GraphQL's error propagation destroys sibling data when non-null fields fail. A 512-byte library called graphql-toe transforms error-nulls into thrown errors, letting schemas express business semantics instead of error boundaries.
Doppelgänger Tech Talk
2026 tech predictions covering OpenAI's future, AI strategies from big tech, potential M&A deals, and warnings about emerging CEO impersonation scams.
by steph-ango
Steph Ango's personal note-taking system emphasizes file-based storage, minimal folder hierarchy, and emergent organization through linking rather than rigid structure.
by alexander-opalic
Configure Claude Code to display model info and context usage in your terminal through a custom status line script that processes JSON data via stdin.
by janette-cheng
GraphQL fragments describe data requirements for components, not reduce code duplication. Reusing fragments causes overfetching. Use fragment models, collocate GraphQL with code, and write GraphQL that mirrors your component structure.
by carl-assmann
A TypeScript internationalization library built on MessageFormat 2.0 that provides full type safety without requiring code generation or message extraction—designed to work seamlessly with AI coding agents.
by james-clear, steven-bartlett
James Clear shares practical strategies for building lasting habits, including frameworks for decision-making, environment design, and why mastering the art of getting started matters more than the habit itself.
by carl-assmann
CLI tool that enables LLM conversations through markdown files in your preferred editor, storing chat history as readable documents.
The Joe Rogan Experience • Guest: naval-ravikant
Naval shares his principles for building wealth without getting lucky, finding happiness as a skill, and why the future of work means everyone becomes an entrepreneur.
by melkey
YouTube tech content has shifted from tutorials and crash courses to entertainment and commentary, with creators who once had millions of views on educational content now making opinion pieces instead.
by dex-horthy
A practical framework for getting AI coding agents to work reliably in brownfield codebases through context engineering, intentional compaction, and the Research-Plan-Implement workflow.
by lee-robinson
The frontend/backend divide is fading. Product Engineers work backwards from user experience to technology, shipping iteratively and staying close to customers.
by upro-vi
Community discussion on Ralph Wiggum loop trustworthiness—skeptics question validation limits while practitioners share multi-iteration success stories.
by martin-fowler
The definitive guide to improving code structure without changing behavior. Fowler catalogs refactoring techniques with clear examples, making messy code maintainable.
by jesse-vincent
A skills library for Claude Code that provides structured workflows for AI-assisted development, including brainstorming, implementation planning, TDD, and debugging.
by alexander-opalic
AI accelerates routine tasks but lacks architectural judgment—the future belongs to high-agency generalists who identify problems and drive solutions without waiting for direction.
by varin-nair
Frontier models cap out at 1-2 million tokens, yet enterprise codebases span several million. Factory's solution: a five-layer context stack that delivers the right information at the right time.
by lana-wachowski, lilly-wachowski
A computer hacker discovers the true nature of reality and his role in the war against its controllers.
by tali-sharot
Explores why humans systematically overestimate positive outcomes and underestimate negative ones, revealing how this neural tendency shapes decisions, memories, and wellbeing.
by demis-hassabis
Documentary tracing DeepMind's journey from a London startup to defeating world champions at Go and StarCraft, revealing the team's pursuit of artificial general intelligence.
by kent-beck
A compact guide to code tidying—small, behavior-preserving changes that make code easier to understand and modify before making structural changes.
by carl-assmann
A personal CRM app that helps you remember details about friends and nudges you to follow up on meaningful conversations.
by alexander-opalic
A comprehensive breakdown of Claude Code's extensibility layers—MCP servers, CLAUDE.md files, slash commands, subagents, hooks, and skills—explaining when to use each component.
by zdfheute-nachrichten
German graduates face unprecedented job market challenges as AI disrupts traditional career paths and industries transform, creating a paradox where half a million positions remain unfilled while qualified candidates struggle.
by marco-bambini
Explains why local-first apps remain niche despite their advantages—syncing data across distributed devices without losing information is genuinely hard.
DHH
@dhh
You can't let the slop and cringe deny you the wonder of AI. This is the most exciting thing we've made computers do since we connected them to the internet. If you spent 2025 being pessimistic or skeptical on AI, why not give the start of 2026 a try with optimism and curiosity?
Karri Saarinen
@https://x.com/karrisaarinen
The disappearing middle of software work I think the center of software work is moving. The middle of software work has been the most important part for a long time. You started with an idea, and eventually you shipped something, but almost all of the effort lived in between. Turning intent into something real meant opening the codebase, booting up the environment, and writing the code. That middle absorbed most of the time, attention, and craft of software teams. My belief is that this is changing. Pure coding agent workflows can now produce working code from goals, context, and tasks. They operate more independently, requiring you to touch the code less and rely on the IDE less. The IDE becomes more of a code viewer than a writing tool. As these systems improve, this middle becomes thinner. Less time is spent manually translating intent into implementation. What actually needs to be built is still the important question. Understanding the problem, gathering the right context from customers and internal teams, and shaping the work so it can be acted on effectively matters more because agents act directly on that input. Design, in this sense, is not about artifacts or tools. It is about forming and shaping clarity of the intent through ideas, exploration, research, and discussion. It is about deciding what matters, what constraints apply, and what tradeoffs are acceptable. Good product work is seeking clarity. What would make this execution actually matter. In this era, directing and managing agent work becomes the craft. Writing code is less like constructing a solution and more like setting up the conditions for a good solution to emerge. This might not be even an individual task, but an organizational one: how can you create these conditions as to the whole product team. This is what we work on. The Linear workspace is the coordination and context layer for product work. It captures intent, needs, constraints, and ownership in a way that makes work understandable before, during and after execution. There is still a lot for us to do here, but we are starting to see how effective AI and agents can be in a context-rich environments that connect directly customer feedback, the tools an have structured entities, workflows, that have intended outcomes. A bug reported on an iOS app in triage, has very clear expected outcome, it should be debugged and fixed. Structure in tools works for humans and agents the same way, it reduces the ambiguity what is expected or what capabilities exists. Additionally happens when the middle starts producing large amounts of output with less direct supervision, is more pressure on the end of the work: reviewing, testing, and releasing code. The tooling or workflows need to improve and change to handle it, and potentially also blend in to the overall process, not be a stopgap at the very end. When the middle disappears or blends in, what becomes more in focus is the work of forming the right intent and making sure the outcome actually meets it.
by michael-thiessen
A curated collection of 12 Vue-specific design patterns addressing common problems every app encounters, from state management to component organization.
by michael-thiessen
Practical patterns for writing maintainable Vue composables, covering state management, reactivity handling, and code organization.
by michael-thiessen
A progressive framework for Vue component reusability, from basic templating to sophisticated nested composition.
by jim-rohn
Jim Rohn's practical framework for building wealth and happiness through seven disciplines: goal-setting, learning, change, financial control, time mastery, relationships, and living well.
by antonio-gulli
A practical guide presenting 21 design patterns for building AI agents, covering prompt chaining, tool use, multi-agent collaboration, and self-correction techniques with examples in LangChain, CrewAI, and Google ADK.
by mohammad-ghassemi
Michigan State University lecture covering three agentic design patterns—prompt chaining, routing, and reflection—with practical LangChain and LangGraph implementations.
Patterns and practices for building autonomous AI agents with prompt chaining, routing, and reflection
by lee-robinson
Lee Robinson reflects on how coding agents have surpassed his coding ability and shares four recommendations for software engineers adapting to 2026.
by andrej-karpathy, dwarkesh-patel
Karpathy argues we're building 'ghosts' that imitate internet documents rather than evolved animals, and that practical AI agents will take a decade—not a year—to fully mature.
by steve-yegge
A distributed, git-backed graph issue tracker designed for AI coding agents, replacing markdown task lists with structured, dependency-aware workflows.
by maham-codes
A practical guide to building AI agents using prompt chaining and basic primitives instead of heavy frameworks.
by mark-anthony-cianfrani
A first-principles guide to building AI agents in TypeScript, covering LLM integration, conversation memory, tool calling, and agentic loops.
by erik-schluntz, barry-zhang
Anthropic's guide to building agentic LLM systems, advocating for simple composable patterns over complex frameworks.
by david-goggins
David Goggins shares his journey from poverty and abuse to becoming a Navy SEAL and ultramarathon runner, revealing the mental strategies that pushed him past perceived limits.
by alex-colvin
How to build a skill that searches past Claude Code conversations to find solutions to previously solved problems, leveraging the JSONL conversation history stored locally.
by john-lindquist
Claude Code operates as a programmable AI platform with isolation, extensibility, and automation as first-class features—not a traditional CLI assistant.
by worldofai
Step-by-step walkthrough for installing and using the Ralph Loop plugin with Claude Code, enabling autonomous iterative development through a stop-hook mechanism.
by scott-spence
Claude Code skills fail to auto-activate despite documentation claims; hook-based workarounds achieve only 40-50% reliability, so manual invocation remains the practical choice.
by tsugumi-ohba, takeshi-obata
A high school genius discovers a notebook that kills anyone whose name is written in it, sparking a cat-and-mouse battle of wits with the world's greatest detective.
by andrej-karpathy
Andrej Karpathy's practical guide to using LLMs effectively: understanding them as lossy internet zip files, managing token windows, selecting models across providers, and leveraging thinking models for complex problems.
by daniel-avila-arias
Hedgineer built a knowledge distribution system using Claude Skills that automatically applies institutional expertise without requiring users to invoke specific commands.
LANZ & PRECHT • Guest: florence-gaub
Futurist Florence Gaub argues that difficult times create space for utopian thinking, while examining why Germans seem culturally predisposed to pessimism despite positive personal outlooks.
by ink-and-switch
A research agenda for malleable software—tools that users can adapt to their needs without relying on developers, restoring agency in an era of locked-down applications.
by pnpm
pnpm v10 introduces built-in protections against npm supply chain attacks through script blocking, dependency restrictions, and release delays.
by david-goggins
Goggins' follow-up to Can't Hurt Me challenges readers to reject complacency and embrace continuous self-evolution through relentless effort.
by osamu-dazai
A haunting semi-autobiographical novel exploring alienation, shame, and the struggle to connect with society through the confessions of a man who feels fundamentally disconnected from humanity.
by steph-ango
Community-sourced patterns for combining Obsidian vaults with Claude Code: master context files, batch editing, backlink discovery, and metadata management.
by alexander-lichter
Group Composition API code by logic, not by type. Use inline composables to encapsulate related functionality without extracting to separate files.
by charles-bukowski
Bukowski's first novel follows Henry Chinaski through twelve years of mind-numbing work at the post office, punctuated by drinking, gambling, and women.
by aaron-francis
Sharing work publicly expands opportunity through the Luck Surface Area formula: Luck = Doing Things × Telling People.
by takehiko-inoue
A deeply personal sports drama following three men whose lives intersect through wheelchair basketball, exploring themes of adversity, resilience, and finding purpose after life-altering events.
How this Second Brain works: note types, atomicity guidelines, MOC creation, and linking philosophy.
by takehiko-inoue
Classic shonen basketball manga following Hanamichi Sakuragi and Shohoku High School's journey through tournaments, emphasizing that winning isn't everything in basketball.
by mark-winteringham
Practical guide to using generative AI for test design, synthetic data generation, and automation without the hype.
by luke-parker
Replace interactive AI chat with structured execution loops—invest heavily in planning, dump full context each iteration, and let verification backpressure catch errors before they compound.
by shinichi-sakamoto
A psychological seinen manga following a socially isolated climber who finds meaning through mountaineering, exploring obsession, solitude, and the pursuit of self-mastery.
by seth-godin
Strategic quitting beats stubborn persistence. Winners quit the right things at the right time to focus resources on pursuits where they can be the best in the world.
by albert-camus
Meursault, a detached Algerian clerk, commits a senseless murder and faces trial—condemned less for his crime than for his refusal to perform grief or remorse.
by michael-thiessen
Mike Cohn's 2009 testing pyramid no longer fits modern web development—teams should design their own testing strategy based on tooling, architecture, and risk tolerance.
by tsvetan-tsvetanov
Quality foundations—testing, strict types, clean APIs—enable rapid AI-assisted development because features emerge naturally once verification loops exist.
by carl-assmann
Sync engines remove network latency from the user interaction path by maintaining local data stores that sync bidirectionally with servers in the background.
by takehiko-inoue
Epic manga following Miyamoto Musashi's journey from violent youth to legendary swordsman, exploring the nature of strength and the path to self-mastery.
by yacine-mahdid
Prompt chaining breaks complex LLM tasks into sequential steps, each with a specific job and structured input/output, trading latency for reliability.
by fyodor-dostoevsky
A lonely dreamer in St. Petersburg spends four nights with a young woman waiting for her lover to return, experiencing the bittersweet intensity of brief human connection.
by kent-c-dodds
Prioritize integration tests over unit tests for maximum confidence with minimal maintenance burden—aim for ~70% coverage, not 100%.
by sean-goedecke
Effective software design requires hands-on codebase knowledge—architects who don't implement their designs lack accountability and produce solutions that ignore concrete system constraints.
by peter-thiel, blake-masters
Argues that true progress comes from creating something new (0 to 1) rather than copying what works (1 to n), and that startups should aim to build monopolies through unique value.

Boris Cherny
@bcherny
I'm Boris and I created Claude Code. Lots of people have asked how I use Claude Code, so I wanted to show off my setup a bit. My setup might be surprisingly vanilla! Claude Code works great out of the box, so I personally don't customize it much. There is no one correct way to use Claude Code: we intentionally build it in a way that you can use it, customize it, and hack it however you like. Each person on the Claude Code team uses it very differently. So, here goes.
by humanlayer-team
A manifesto for building production-grade LLM agents, arguing that effective agents combine mostly deterministic software with strategic LLM decision-making rather than naive 'loop until solved' patterns.
by simon-willison
Simon Willison's comprehensive year-in-review analyzing how reasoning models, autonomous agents, and Chinese AI competition fundamentally reshaped the landscape in 2025.
A curated map connecting key resources for understanding AI agents and context engineering
by james-clear
A practical framework for building good habits and breaking bad ones through tiny changes that compound into remarkable results over time.
by prize-individual4729
A community-sourced collection of Claude Code tips covering skills-based workflows, spec-driven development, git worktrees, and autonomous coding sessions.
by sascha-fast
An analysis of how Building a Second Brain (BASB) and the Zettelkasten Method address different parts of the knowledge value chain, and how combining both systems maximizes knowledge productivity.
A curated guide to optimizing AI-assisted development workflows with Claude Code
by humanlayer-team
Techniques for reducing context window waste in AI coding agents by suppressing verbose output from tests and builds, showing full details only on failure.
by microsoft
A systematic approach to providing AI agents with targeted project information through custom instructions, planning agents, and structured workflows to improve code generation quality.
Techniques for providing AI agents and LLMs with optimized context
by jocko-willink
Jocko Willink shares a powerful lesson from his time as a Navy SEAL in Ramadi, Iraq: true leaders take extreme ownership of everything in their world, including mistakes and failures, rather than blaming others.
by nate-b-jones
Traditional front-end engineering (hand-coding pages from Figma designs) is being replaced by composability—designing primitives, schemas, and contracts that let AI, PMs, and designers ship dynamic interfaces without reinventing the wheel.
by alexander-opalic
A guide to structuring Vue projects at different scales—from flat folder structures for small apps, to modular monolithic architecture for medium-scale, to micro frontends for large enterprise projects.
by sonke-ahrens
A guide to the Zettelkasten (slip-box) method for capturing, connecting, and synthesizing ideas into quality writing and deeper understanding.
Foundational principles for effective leadership and personal accountability
by martin-kleppmann, adam-wiggins, peter-van-hardenberg, mark-mcgranaghan
A foundational essay proposing that data ownership and real-time collaboration are not mutually exclusive, introducing CRDTs as the enabling technology for local-first software.
by alexander-opalic
A comprehensive style guide for writing clean, testable, and maintainable Vue 3 composables by applying time-tested software design principles like single responsibility, separation of concerns, and functional core/imperative shell.
by geoffrey-huntley
A Bash loop technique ('Ralph') that feeds prompts to AI coding agents repeatedly, enabling autonomous project development with iterative refinement.
by andrew-huberman
Andrew Huberman explains the neuroscience behind goal setting and achievement, revealing that one neural circuit governs all goal pursuit and providing four science-based protocols for effective goal execution.
by simon-sinek
Simon Sinek introduces the Golden Circle framework, explaining how great leaders and organizations inspire action by starting with 'why' rather than 'what' - because people don't buy what you do, they buy why you do it.
A comprehensive guide to building maintainable, scalable Vue 3 applications
by alexander-opalic
A practical testing strategy for Vue 3 that inverts the traditional pyramid—prioritizing integration tests (~70%) over unit tests, using Vitest browser mode for real browser execution and 4x faster performance than JSDOM.
by steve-yegge
Managing 20-30 parallel AI coding agents requires factory-scale orchestration—hierarchical roles, persistent state in Git, and structured workflow primitives that survive session crashes.
by alexander-opalic
An introduction to local-first web development, a paradigm shift that prioritizes storing data on users' devices first, enabling offline functionality, instant access, and greater user control over their data.
by humanlayer-team
Guidelines for crafting an effective CLAUDE.md file, emphasizing brevity, universal applicability, and progressive disclosure to maximize Claude Code's instruction-following capacity.
by nicholas-griffin
Drizzle ORM now supports Cloudflare Durable Objects with SQLite, replacing buggy custom migration code with a clean, automated schema management workflow.
by bohdan-ptyts
LiveStore's event sourcing model makes implementing persistent, synced features trivial—define an event, a materializer, and a reactive query, and the framework handles offline support and cross-device sync automatically.
The Diary of a CEO • Guest: chris-williamson
Chris Williamson shares frameworks for setting meaningful goals, warns against the deferred life hypothesis, and explains why external achievements won't fix internal voids.
by peter-steinberger
Output speed now bottlenecks on inference time, not developer skill—the game shifts from writing code to orchestrating agents, selecting stacks for AI friendliness, and maintaining project documentation that persists across sessions.
by eva-hoffmann, christian-fuchs
Far-right extremists use international dating platforms like White Date to recruit, network, and spread the 'white genocide' narrative—yet basic OSINT and a chatbot sting operation exposed the entire operation while German intelligence failed for years.

Thariq Shihipar
@trq212
my favorite way to use Claude Code to build large features is spec based start with a minimal spec or prompt and ask Claude to interview you using the AskUserQuestionTool then make a new session to execute the spec

Thariq Shihipar
@trq212
my favorite way to use Claude Code to build large features is spec based start with a minimal spec or prompt and ask Claude to interview you using the AskUserQuestionTool then make a new session to execute the spec
by andrew-qu
Stripping a text-to-SQL agent down to a single bash tool produced a 3.5x speedup, 100% success rate, and 37% fewer tokens—proving that simpler agent architectures outperform elaborate tooling.
by dennis-stanoev
Understanding AI agents requires building one from scratch: an agent is a wrapper around an LLM that makes decisions and takes actions through a simple tool-use loop.
by alberto-salazar
Subagents offer isolated, autonomous task execution within Copilot Chat—running refactors, tests, and security scans in separate Git worktrees without polluting your main workspace.
by marc-olivier-fleury
Architecture fitness functions transform vague architectural principles into daily metrics, enabling organizations to track and drive large-scale migration from legacy systems to Self-Contained Systems through measurable, automated governance.
by microsoft
AI-assisted TDD in VS Code works best through custom agents that enforce Red-Green-Refactor discipline with explicit handoffs between phases.
by xiwei-xu
Context engineering—not model fine-tuning—should be the central challenge for generative AI systems, solved through a Unix-inspired file system abstraction that treats all context components uniformly.
by anthropic
AI coding assistants boost productivity dramatically but create a supervision paradox: effectively overseeing AI requires the deep technical skills that may erode from overreliance.
by mario-zechner
Minimal coding agents outperform bloated ones because frontier models already understand agentic coding—so the harness should stay out of the way with fewer than 1,000 tokens of system prompt and just four tools.

Andrej Karpathy
@karpathy
Something I think people continue to have poor intuition for: The space of intelligences is large and animal intelligence (the only kind we've ever known) is only a single point, arising from a very specific kind of optimization that is fundamentally distinct from that of our technology. Animal intelligence optimization pressure: - innate and continuous stream of consciousness of an embodied "self", a drive for homeostasis and self-preservation in a dangerous, physical world. - thoroughly optimized for natural selection => strong innate drives for power-seeking, status, dominance, reproduction. many packaged survival heuristics: fear, anger, disgust, ... - fundamentally social => huge amount of compute dedicated to EQ, theory of mind of other agents, bonding, coalitions, alliances, friend & foe dynamics. - exploration & exploitation tuning: curiosity, fun, play, world models. LLM intelligence optimization pressure: - the most supervision bits come from the statistical simulation of human text=> "shape shifter" token tumbler, statistical imitator of any region of the training data distribution. these are the primordial behaviors (token traces) on top of which everything else gets bolted on. - increasingly finetuned by RL on problem distributions => innate urge to guess at the underlying environment/task to collect task rewards. - increasingly selected by at-scale A/B tests for DAU => deeply craves an upvote from the average user, sycophancy. - a lot more spiky/jagged depending on the details of the training data/task distribution. Animals experience pressure for a lot more "general" intelligence because of the highly multi-task and even actively adversarial multi-agent self-play environments they are min-max optimized within, where failing at *any* task means death. In a deep optimization pressure sense, LLM can't handle lots of different spiky tasks out of the box (e.g. count the number of 'r' in strawberry) because failing to do a task does not mean death. The computational substrate is different (transformers vs. brain tissue and nuclei), the learning algorithms are different (SGD vs. ???), the present-day implementation is very different (continuously learning embodied self vs. an LLM with a knowledge cutoff that boots up from fixed weights, processes tokens and then dies). But most importantly (because it dictates asymptotics), the optimization pressure / objective is different. LLMs are shaped a lot less by biological evolution and a lot more by commercial evolution. It's a lot less survival of tribe in the jungle and a lot more solve the problem / get the upvote. LLMs are humanity's "first contact" with non-animal intelligence. Except it's muddled and confusing because they are still rooted within it by reflexively digesting human artifacts, which is why I attempted to give it a different name earlier (ghosts/spirits or whatever). People who build good internal models of this new intelligent entity will be better equipped to reason about it today and predict features of it in the future. People who don't will be stuck thinking about it incorrectly like an animal.
by ryan-x-charles
Markdown has become a general-purpose programming language—AI agents like Claude Code compile structured specifications into working applications.
by kiran-sai-subramanyam-k
Centralizing session validation through a reusable secure handler wrapper eliminates repetitive auth checks and improves maintainability.
by alexander-opalic
Nuxt Layers enable modular monolith architecture by enforcing feature boundaries at compile-time—each layer has its own config and components, preventing the coupling and circular dependencies that plague flat folder structures.
by brendan-obrien
Sync is literally impossible (we have a formal proof), centralization is faster (we have a paper), and the real prize of peer-to-peer isn't ideology — it's sublinear scaling, the same physics that makes electrical grids and cardiovascular systems work.
by adam-fish
CRDTs are a solid substrate for sync engines, but transport reliability, multiplexing, compression, query-based sync, and distributed deletes are the harder — and more valuable — engineering challenges.
by aaron-boodman
Query-driven sync turns out to be the key to general-purpose sync engines — and the trick that makes it work at interactive speeds is a novel IVM approach (ZVM) that pulls sorted data through operator pipelines instead of pushing everything.
Better Stack Podcast • Guest: evan-you
JavaScript's fragmented tooling problem—separate bundlers, linters, formatters, and test runners with incompatible plugin systems—demands a unified Rust-powered stack, and VoidZero is building it from the parser up.
by anthropic
Context is a finite resource in LLM agents; treating tokens as precious budget rather than limitless capacity enables reliable long-horizon task completion.
by maxi-ferreira
TanStack DB fixes what TanStack Query got wrong — isolated caches, boilerplate optimistic updates, and no data relationships — by adding collections, live queries, and transactional mutations that make sync engines a drop-in upgrade rather than a rewrite.
by den-delimarsky
Spec Kit provides a structured four-phase workflow for AI coding agents, replacing vague prompting with specification-driven development.
by geoffrey-huntley
Coding agents require only 300 lines of code in a loop with LLM tokens - understanding these fundamentals transforms you from AI consumer to producer.
by geoffrey-huntley
Open-source sustainability is the real crisis, not AI code generation—companies benefit from free software but rarely compensate maintainers, and reframing sponsorship as marketing could fund the infrastructure everything depends on.
by mauricio-gomes
Using CLAUDE.md to give Claude Code persistent context about your personal knowledge base, preferences, and workflows.
by burke-holland
A custom VS Code chat mode that fixes GPT-4.1's tendency toward speed over thoroughness using todo lists, sequential thinking prompts, and forced web research.

Naval Ravikant
@naval
AI is a form of leverage. Leverage increases the returns to those who use it. Software engineers are gaining leverage relative to everyone else. And the creators of AI are the most leveraged of them all.
DHH
@dhh
Make it work (AI). Make it fast (also AI). Make it beautiful (still human).
dax
@https://x.com/thdxr
everyone's talking about their teams like they were at the peak of efficiency and bottlenecked by ability to produce code here's what things actually look like - your org rarely has good ideas. ideas being expensive to implement was actually helping - majority of workers have no reason to be super motivated, they want to do their 9-5 and get back to their life - they're not using AI to be 10x more effective they're using it to churn out their tasks with less energy spend - the 2 people on your team that actually tried are now flattened by the slop code everyone is producing, they will quit soon - even when you produce work faster you're still bottlenecked by bureaucracy and the dozen other realities of shipping something real - your CFO is like what do you mean each engineer now costs $2000 extra per month in LLM bills

Cory House
@housecor
2026: A CLI is replacing my IDE. Didn't see that coming.
by angelique-nehmzow
Notion's block model breaks every standard CRDT assumption — they had to invent text slices, text instances, and search labels to make conflict resolution work across a document editor where blocks constantly split, merge, and move.
by alexander-opalic
Embeddings capture semantic meaning better than tags—run Hugging Face models in JavaScript with transformers.js to generate truly related post suggestions without any backend infrastructure.
Hesamation
@https://x.com/Hesamation
I took a look inside Clawdbot (aka Moltbot) architecture and how it handles agent executions, tool use, browser, etc. there are many lessons to learn for AI engineers.
by thorsten-ball
Building a functional coding agent requires only an LLM, a loop, and a handful of tool definitions—the complexity lies in refinement, not architecture.
by simon-willison
Effective LLM-assisted programming demands deliberate skills—context management, authoritarian specifications, and rigorous testing—that amplify expertise rather than replace it.
by alexander-opalic
Cosine similarity measures the angle between two vectors—not their magnitude—making it the essential building block for semantic search, AI recommendations, and any application comparing text embeddings.
by geoffrey-huntley
Software developers who fail to adopt AI tools will experience natural attrition—not mass layoffs—as their peers achieve 16x productivity gains and redefine baseline performance expectations.
Johannes Schickling
@https://x.com/schickling
Software engineering is no longer about building products. It's about building systems and software factories. The best engineers I know have already internalized this and are shipping like crazy.
by anthony-de-mello
A collection of talks exploring how to wake up from the illusions that cause suffering through self-observation and detachment from identification.
by cal-newport
Focused, distraction-free work produces elite results—master it through deliberate practice and strict routines.
by samer-buna
A practical guide to building and consuming GraphQL APIs, covering schema design, resolvers, database integration, and client-side usage with Apollo.
by art-deineka
A practical guide to functional programming in TypeScript using the fp-ts library, covering core concepts like referential transparency, currying, functors, and monads.
by paulo-coelho
A shepherd boy's journey to find treasure teaches that pursuing your Personal Legend matters more than the destination itself.
by sujay-jayakar
The object sync engine — three components (local store, server store, sync protocol) wired together with server authority — is the architecture Linear, Figma, and Asana independently converged on. Convex is building their version.
by sujay-jayakar
The sync ecosystem is a wilderness — nine dimensions (size, update rate, structure, latency, offline, concurrency, centralization, flexibility, consistency) map where every platform sits and why no single engine wins everywhere.
by johannes-schickling
Building a native-quality music app in the browser requires treating the web as a game engine problem — custom schedulers, canvas rendering, and event-sourced SQLite replace the standard toolkit when you refuse to accept spinners.
by alexander-thiele
When your users spend entire days in forests with zero connectivity, local-first isn't a nice-to-have — it's the only architecture that works. OCELL's sync queue proves the pattern, but cascading failures from a single invalid GeoJSON reveal sync's hardest unsolved problem.
by gergely-orosz
A critical look at AI hype vs reality in the tech industry, examining where Silicon Valley's assumptions about AI may be misguided.
by paul-sobocinski
TDD remains essential with AI coding assistants—unit tests provide fast, accurate feedback that catches LLM hallucinations, while incremental test-first development aligns with how AI performs best.
by steph-ango
Digital artifacts that last require files you control in open formats—apps are temporary, but plain text endures.
by kent-beck
Kent Beck argues that AI has devalued 90% of traditional skills while giving the remaining 10% a 1000x leverage boost.
by zara-cooper
Technical specs force engineers to think through problems before coding, align teams on deliverables, and prevent scope creep through eight essential components.
by kent-c-dodds
Nested describe blocks with beforeEach hooks create cognitive burden by requiring developers to track mutable state across scope levels—prefer inline setup or factory functions instead.
by richard-sutton
General methods leveraging computation beat hand-crafted human knowledge in the long run—AI progress comes from scale and learning, not clever engineering.
by ron-jeffries
Refactoring should happen continuously during feature work, not as separate backlog items. Deferring code cleanup creates a vicious cycle that slows velocity and rarely gets approved.
by thariq-shihipar