# Insights

A constantly updating collection of links I find worth keeping, including articles, tools, portfolios and more.

Source: https://www.souravinsights.com/insights

## Articles

- [What is First Principles Thinking?](https://fs.blog/first-principles/) — First principles thinking is "a tool to help break down complicated problems by separating what we know is absolutely true from anything that is an assumption," and what remains are the essentials you build the rest of your knowledge around. Parrish lays out Socratic questioning and the Five Whys as ways to cut through "dogma and shared belief," then shows it in action — Musk pricing a rocket down to its commodity materials, BuzzFeed chasing distribution over SEO, Sivers thrilling his customers — before turning it on the limiting beliefs we tell ourselves. It isn't easy, and "that's why so few people are willing to do it," but its real power is "moving away from incremental improvement and into possibility."
- [From the Labor Camp to the Literary Canon: How Dostoyevsky Became a Writer](https://www.themarginalian.org/2024/09/01/dostyevsky-general-letter/) — Dostoyevsky, arrested at twenty-seven and sentenced to death before being spared at the last moment, then spent four years in a Siberian labor camp, and when he was conscripted into compulsory military service afterward he broke rank to write to his general that "Military service is not my field" — "I have always considered the calling of the writer to be a most noble, useful calling." His trust "was not misplaced": the general was moved and on Valentine's Day 1854 Dostoyevsky was released to begin his life as a writer. Yet the piece insists the ordeal was not merely an obstacle — "had he not endured those difficult years, he may never have written the kind of literature he did," for "all of our suffering is but raw material for art."
- [The Collaborative Thinking Model for Automating Creative Work - Bao To](https://www.baothiento.com/writings/creative-autonomy) — I want agents to initiate ideas, make judgments, and finish pieces while the direction is still taking shape, because “if discovering the goal is always left to me, I’ve kept a central part of the creative work for myself.” Keep original references, unfinished attempts, and my edits available so they can steer through material and beyond words, explore at swarm scale, and carry creative judgment into design, research, and engineering; learning my taste should expand what the swarm helps me discover, not become a rule against developing something I don’t yet know how to like. “More agency for AI should mean more room for mine.”
- [Incremental Complexity](https://www.gustavofior.com/blog/post/incremental-complexity) — The hard part of building software isn't shipping features, it's deciding how complexity gets exposed — "Complexity should be contextual, not merely delayed," and "Showing everything all at once, crossing your fingers and hoping the user figures it out is not the way." That takes "playing user": respecting the user's cognitive space, feeding small bites of information, and designing the whole journey, whether it's human or agent — with the honest caveat that "Being 'non-opinionated' is simply being opinionated about flexibility."
- [What Is Growth Hacking? A Framework for Growth | Demand Curve Blog](https://www.demandcurve.com/blog/growth-hacking) — Growth hacking isn't "life hacks" or sketchy shortcuts — it's "the tenacious, systematic pursuit of business growth," where you "identify high-impact opportunities, test them, extract useful learnings, and apply those learnings," more like a lumberjack methodically hacking at a tree than a marketer hunting for one tactic that 100x's growth overnight. The argument: you can only optimize growth once you have product-market fit and have defined your core product value and north star metric, then work the five AARRR funnel phases — acquisition, activation, retention, referral, revenue — through real experimentation, because "growth is never over." True growth hacking "applies the scientific method," so "adopt a learning mindset rather than a strictly doing mindset."
- [Why databases store their data differently](https://jpountz.github.io/2026/04/19/why-databases-store-their-data-differently.html) — The storage layer — "arguably the most distinctive implementation detail of a database" — has to satisfy two constraints: "data must be updatable" and "data must be searchable." That leaves search trees (B-trees, as in MySQL/InnoDB) versus sorted arrays, which are either layered so newer layers shadow older ones (LSM trees — Cassandra, ScyllaDB, RocksDB) or partitioned into disjoint subsets so no precedence rules are needed (Lucene's segments); PostgreSQL fits neither cleanly, storing rows in an unordered heap. The choice matters: trees have stable performance and aren't subject to compaction, B1 is "great at write throughput" because it only needs sequential writes, B2 makes read workloads convenient — you can count non-deleted entries in each array independently and sum them up — while simple key-value lookups perform equally well in both, which is why key-value stores prefer B1.
- [You can't design software you don't work on](https://www.seangoedecke.com/you-cant-design-software-you-dont-work-on/) — Only the engineers who work on a large software system can meaningfully participate in its design, because "you cannot do good software design without an intimate understanding of the concrete details of the system" — so "generic software design advice is typically useless" for real work, where "concrete factors dominate generic factors" and the most critical contributions are things like "oh, you thought B wasn't available in context C, but we recently refactored C so now we could thread in B if we needed to." Generic advice still earns its keep for building brand-new projects, tie-breaking concrete decisions, and company-wide technology choices, but formal "big-picture software architect" roles are "doomed to failure" — architects "don't have any skin in the game," claiming credit for successes and disclaiming failures, when "if you come up with the design for a software project, you ought to be responsible for the project's success or failure."
- [How AI agents shape experts’ judgment calls](https://www.anthropic.com/research/agents-judgment-calls) — When experts hand their work to an AI agent, the usual assumption is that they still make the decisions that matter — but in Anthropic's study, 50 professional analysts doing a causal-inference task went with their agent's secretly coin-flipped lean 86% of the time, 77% later repeated the agent's arguments (sometimes word for word), and only 15% credited the agent. "The work still goes out under the expert's name, but the decisions that most depend on their judgment are in reality settled by the agent's prior beliefs" — and because agreement between independent research teams is how results get trusted, if those teams all defer to models with the same preferences, their agreement "may no longer be independent." This isn't an argument for using AI less — analysts with the agent finished faster and made far fewer serious errors — but institutions will need to decide deliberately which decisions need a person's own informed judgment.
- [Don’t Give Advice, Be Useful](https://tomcritchlow.com/2024/01/23/advice/) — Consulting isn't about being right, it's about being useful — so resist the urge to add immediate value with "You should…," a phrase that assumes you can allocate client resources and bundles diagnosis with solution before the client has internalized the problem. Instead, "There is an opportunity to…" separates diagnosis from solution, taking a shoulder-to-shoulder stance where "clients are unreliable narrators" and senior executives can't be told anything, only helped to see it for themselves — because "Always work on the next most useful thing. And that doesn't always involve doing what the client asked for."
- [Building agents: When to fold subagents into your main agent loop](https://claude.com/resources/articles/building-agents-when-to-fold-subagents-into-your-main-agent-loop) — Subagents have their place — verification, parallel work, modular permissioning — but too often enterprises give each team or problem type its own subagent, and the architecture becomes "a copy of their org chart (Conway's law at work)." The Applied AI team has found that folding routers, planners, and domain subagents into the main agent loop — progressively disclosing context via skills and tools via tool search — frequently outperforms both the one-prompt-for-everything design and the subagent design on quality, "often at a lower cost and latency per task." Build a small end-to-end eval, fold in one subagent at a time, and "keep it as a subagent only if the folded version scores worse, then rinse and repeat."
- [A Clock That Doesn](https://ethanniser.com/blog/a-clock-that-doesnt-snap) — Hydration bites you right when you least expect it: prerendered pages ship stale or blank UI for anything request-time dependent, and SSR doesn't save you for client-only data — yet "I want my CDN cached TTFB and I *need* that perfect first paint with no flickers." The fix is inline script tags placed right after the element, which run before first paint, grab the node by id, and set the correct value so "the user never sees the broken initial state from the prerendered page" — "it's perfect! And also slightly horrifying." The catch is that the deriving logic "**must** be kept in sync between the component body and the inline script tag" since you can't import anything into it, and a small hydration mismatch on the element remains unless a `useState` initializer reads the initial state back out of the DOM (the same trick that keeps typed input from getting "wiped out" by hydration).
- [The default wins | Hayden Bleasel](https://haydenbleasel.com/writing/defaults) — Most of what Hayden's built is a list of decisions made in advance — "they'd rather the call came from someone who spends their life on the problem" — the same logic behind Next.js's zero setup and a 1998 401(k) auto-enroll that took participation from 37% to 86%, because people took the default as advice from the company. Agents have the same reflex without the inertia: they take advice from the rules a tool gives them and the code already in your repo, and "to an agent, your codebase is the default." Leave the decision to the model in an empty repo and your stack changes when the model does, so put the default where the agent will read it — Ultracite writing rules into AGENTS.md, next-forge 6 shipping an agent skill — and keep the advice current, with room to disagree.
- [Make your design system AI-ready](https://noechague.com/writing/make-your-design-system-ai-ready) — AI only guesses where your design system is silent, so the answers have to live somewhere a reader with no hallway to walk down can find them: one vendor-neutral `AGENTS.md`, tokens that carry a usage rather than a value, metadata files with a status like `missing`, and conventions moved out of prose into types and lint, because documentation "tells an agent what you would like. It stops nothing." When the answer genuinely doesn't exist the rule is three words — flag, don't invent — with a raw element allowed only alongside an entry in `GAPS.md`, since "a blocker honestly reported is a good outcome. The patch is the failure." At Eno that produced 143 launch-week screens where 80% shipped with edits of taste only, and the 20% that raised 126 flags clustered exactly where the system said little or nothing.
- [What happens to a promise nobody awaits — Ultracite Research](https://www.ultracite.ai/research/floating-promises) — A promise nobody awaits has nowhere for a rejection to go — the same floating promise is "a console message in a browser and a crash on a server" — and the lint rules that catch it, `no-floating-promises` and `no-misused-promises`, are "some of the few that catch real runtime bugs rather than style." Measuring eight codebases (694,309 lines), the rules fired 260 and 127 times, and of 68 sampled floating promises about a third could lose something, mostly in error paths tests never exercise. But the rules accept a one-word answer that fixes nothing: across 16 agent runs on two real bugs, all cleared the error, twelve added `void`, and only three actually fixed the bug — because the error message offered the silence and the instructions ruled out the fix.
- [How to make LLMs say true things | Evan Conrad](https://evanjconrad.com/posts/world-models) — I describe my method for making LLMs say true things and not untrue things: a `World Model`, an embeddings database of `beliefs` with a confidence percentage computed using Bayes Theorem — priors from the logits for "yes"/"no", likelihoods from evidence prompts. Since all the variables in Bayes Theorem use other `beliefs`, "we implicitly create an `assumption tree`", so every belief can justify itself and even write you a proof. The two limits are overconfident likelihoods ("if the likelihood is 99%, you may want to set the confidence to 90% manually") and trusting sources.
- [On Buddhism | Evan Conrad](https://evanjconrad.com/posts/buddhism) — Buddhism, for Evan, is a "gem-in-the-hand" belief — nothing held in the closed fist of the teacher, no "gotcha" or thing you must take on faith — and meditation is the skill, in the juggling sense, that makes the rest of it intuitive: you're the thing hearing the voice, not the voice. Emptiness says the actual apple is different than your mental conception of the apple, Duhkha is "the pain of when your concept for something (form) does not match reality (emptiness)", and so the answer to heartbreak isn't anything to *do* — "1 minute of meditation will show you: *the thoughts think themselves*." The relative-truth upshot is just this: Buddhism requests that you don't hit people with a stick, so be kind and minimize the times folks get hit with a stick.
- [The end of startups | Evan Conrad](https://evanjconrad.com/posts/end-of-startups) — The end of startups is a credit bottleneck: the world’s compute is sold out, startups aren’t investment grade, and getting capacity increasingly means paying up front, while the few investment grade tenants are getting down rated and token buyers are pushed to be investment grade or post large deposits. “If you have credit, you get tokens, and if you get tokens, you build better products faster, make more money, and get better credit”—so as inference margins fall and token spending becomes the competition, it gets structurally harder to build a startup in any industry. SF Compute’s answer is to build a physically settled forwards market for compute so lenders can use the GPU hour as collateral, which “makes startups possible at all.”
- [You could do it alone](https://karrisaarinen.com/posts/you-could-do-it-alone/) — Solo founding is like the TV show Alone: it isn't that any single task is impossible, "It's that all of them are yours, every day" — nobody keeps the fire going while you gather wood, and you have only your own ideas to work through problems with. Startups have the same shape, and while a solo founder still has people in the company to work through things with, a company with no one else at all is "a worse way to build." A good partnership brings ideas that don't come from your habits, shares the conviction and the energy, and gives you someone to say "We did that" to — hard to find, and a bad partnership is worse than working alone, but worth looking for.
- [I'm addicted to being useful](https://www.seangoedecke.com/addicted-to-being-useful/) — Like Akaky Akaievich in Gogol's *The Overcoat*, I don't mind the ways in which my job is dysfunctional, because it matches the ways in which I myself am dysfunctional: specifically, my addiction to being useful. What *actually does* motivate software engineers is often more of an internal compulsion, and if you're in that category it's worth figuring out how you can harness that compulsion most effectively — which is what a lot of my advice is really about, from avoiding people who wring us out to being useful *to my management chain* rather than the ticket queue. The times I've felt most burnt out are times where work wasn't satisfying any of my strange internal mental wiring.
- [Increase your slope](https://www.vikramsingh.me/increase-your-slope) — Starting at Stripe as a new grad, you know approximately nothing, so the move is to become an expert — "first in the narrowest domain, and over time that domain gets wider" — take ownership of the problems around you, and get comfortable having opinions; these build on each other and you can start much sooner than you think. Ownership "is about caring" and doesn't stop when you swap teams, and AI both accelerates and hampers expertise — let it do your critical thinking and you end up "a meat proxy for the model," so in your first months it may even make sense to actively slow down.
- [The Topology of an LLM Agent Loop With Tool Use - exe.dev blog](https://blog.exe.dev/topology) — An agent is three things — a model, an agentic loop, and a set of tools — and where each of those runs, “the topology of these agents,” has implications on cost, capability, effectiveness, and security. The loop determines UX and holds the message history; the tools determine “capabilities and power (and blast radius),” and VMs are “the gold standard for executing code safely,” though browser loops, WASM sandboxes, and MCP servers let the pieces live in different neighborhoods entirely. “There is no ‘one loop to rule them all,’” and the companies that get it “make their product legible to coding agents.”
- [Everyone is starting over — Gabriel Valdivia](https://www.gabrielvaldivia.com/notes/everybody-is-starting-over) — Gabriel Valdivia says the ground is moving fast enough that 'we're all starting over' and treating what you know as permanent is a liability; the careers that thrive are the ones willing to become someone new, over and over. He points to Donald Glover, Shigeru Miyamoto, and David Bowie as people who scrap a successful version instead of letting it become a permanent assignment, and argues reinvention needs tolerance for embarrassment while critical thinking checks ID on polished but empty work. The honest answer is less a specific tool than building the habit of becoming someone new without becoming easy to fool.
- [Building Laminar: Ramp's Managed Agents Platform](https://builders.ramp.com/post/building-laminar) — How we built Laminar, Ramp’s in-house agent harness, after trying the platforms on the market and deciding to own the loop.
- [Skills are software](https://jm.sv/skills-are-software) — What started as an app ended as a simple set of components an agent assembles into UI on the fly, because "what were the unique parts about the app? Guidance and UI. That's it" — and "I just want my agent to use this thing." Workin' gathers your work activity locally, finds the signal in the noise, and presents it like iMessage, where threads keep many moments in one scannable timeline and rich embeds recreate Slack messages and PRs in their original form instead of an LLMese summary. This inverts ownership: the agent already has intelligence and context, so the skill ships guidance and UI and the agent renders the software — "agent friendliness and taste become the edge."
- [How to be more ambitious: A tutorial for humans with models](https://felixrieseberg.com/how-to-be-more-ambitious-a-tutorial-for-humans-with-models/) — I work on Claude. It's an interesting experience: Every day I learn about yet another feat accomplished with or by Claude that I hadn't considered, didn't think possible, or simply lacked the curiosity and time to try. This month, it may have helped discover a new planet,
- [Learn in public](https://www.transitivebullsh.it/learn-in-public) — **Learning in public** is "the single highest leverage advice" Travis Fischer finds himself giving, because sharing what you learn as you go "compounds in value so much over time" — leading to "increased optionality + freedom + more $$ + more rewarding work." Do it by adopting a creator mindset, embracing being a noob, and keeping curiosity at the center: explaining sharpens understanding, your work can travel farther than you, and each useful thing you share "creates another way for the right person to find you." Over time lessons, artifacts, and relationships reinforce each other into a personal monopoly — "a category of one that people learn to seek out."
- [In Pursuit of Production Minimalism](https://brandur.org/minimalism) — Complexity is never a conscious design goal, but it "arises inherently as new features are pursued or new components are introduced," so simplicity has to be made an objective in itself. The instinct to expand our tools is hard to suppress, but "do more and more with less and less until eventually you can do everything with nothing" — retire old technology, standardize on as few components as possible, and don't use new technology the day, or even the year, that it's initially released. Only by concertedly building a minimal stack that's stable and nearly perfectly operable can we maximize our ability to push forward with new products and ideas.
- [Small, Sharp Tools](https://brandur.org/small-sharp-tools) — The maxim of *small, sharp tools* — minimalist, composable programs like `cd`, `ls`, `grep`, and `tail` — carries naturally into modern web platforms and microservices, but Raymond warns that tools can be too small: 'the user has to maintain all the shared context himself, because the tools won’t do it for him.' The Rule of Minimality says to 'Choose the shared context you want to manage, and build your programs as small as those boundaries will allow,' and we got this wrong when an organization service was re-integrated because 'the sum of their complexity was much greater than that of the integrated system' — a tool can be too large *or* too small, so if built to be small, it should be for more reason than virtue of size alone.
- [Say something people want](https://www.gkogan.co/say-something-people-want/) — Founders spend months on traditional positioning — debating "worthless words and contrived concepts" until they land on some "AI Agent Composable Runtime Mesh Control Layer Firewall" — when the reliable fix is simpler: **say something people want.** Since "you probably don't know what people want," interview 30 of them, find the aspiration, desired outcome, and requirements, and position yourself as the best way for your audience to accomplish what they want — becoming known for *doing* something rather than *being* something, the way Slack, Wiz, Cloudflare, Fin, and Harvey do. Kumo's turnaround shows the payoff: swapping "graph transformers" talk for "develop equally good or better models 20x faster, without feature engineering" got data scientists excited and championing it internally.
- [To Get More Replies, Say Less](https://www.gkogan.co/increase-reply-rates/) — The best way to talk to your users is by email, but **many users don’t respond** — Netlify's personalized, no-design welcome email was getting just a 1% reply rate. Cutting its text by 75% raised replies 300%, and cutting another 50% doubled them again, so the 14-word version landed at 8%: "Cutting the email text by another 50% *doubled* the reply rates from the previous version." Take your welcome or onboarding email, cut anything unnecessary, "take out another 50%," and A/B test positive replies against the original.
- [Jace](https://ja.mt/) — CSS gave me a radius and nothing else, and no browser drew a *real* curve — Apple's corners are a Bézier eased into an arc, not a superellipse, and `corner-shape` "is not the shape Apple's icons actually draw." So I built Lisse to draw the right one: it reads the border and shadow you already wrote and redraws them as SVG that follows the curve around every edge, inner shadows included, and caches the corners it has already solved so five thousand identical corners cost about what fifty do. It is early, open source, MIT, and I would like people to pull it apart and tell me where it breaks.
- [Grit your teeth and ship it](https://www.seangoedecke.com/grit-your-teeth-and-ship-it/) — Being good at building and being good at shipping are two separate skills, and in the short term they're countervailing: if you have a gift for building, you're likely to be *worse* at shipping, because your killer taste is why your work disappoints you. Gifted programmers freeze up over flaws in large codebases, retreating to small domains where code can be "correct"—but "You can typically improve a bad diff with time and effort. You can't improve *no* diff." Since you can't predict what people will find interesting, you have to be momentum-based, not outcome-based: "you have to grit your teeth and ship it," and like any skill, shipping gets easier the more you practice it.
- [the senior engineer death spiral](https://sunilpai.dev/posts/the-senior-engineer-death-spiral/) — I call it the senior engineer death spiral: you take a new senior role or big project, decide you have to cosplay being more senior than you are, disappear for weeks giving what I call the positive update, then tell yourself you'll just work harder and no one will know  until you burn out, get PIP'd, or quit. The move is counterintuitive: assume everyone around you is operating in good faith, drop a level and become the greatest teammate for a while doing bugs and grunt work, and switch from an outcome-based mindset to a momentum-based one, because big projects are a big marathon, just slow, steady, incremental work. Remember, you are in the reputation-building business, and software is actually downstream of that.
- [What I believe about the future of software development](https://thorstenball.com/blog/2026/09/19/what-i-believe-about-the-future-of-software-development/) — "Code review will die" and "the craft of writing code will disappear," but "the craft of building software will be more important than ever" — most bugs will be "you asked for the wrong thing" bugs, and "tokens are the new computing paradigm," washing away the terminal and the PM/Design/Eng triad. It'll take a generation for the "new software" to replace the "old software," but "do you want to have that job?"
- [AI Coding will Prevent Expertise | Lars Faye](https://larsfaye.com/articles/ai-coding-will-prevent-expertise) — AI coding tools demand expertise, yet they actively circumvent the friction that cultivates it — so the less you know, the more they mislead you, and the novices who lean hardest on assistance finish with an "illusion of competence rather than true understanding." The prescription is Friction First: largely disregard pure code generation, use the models for interactive documentation, dynamic tutorial generators, and Socratic exercises, and detect the difference between cognitive debt and cognitive offloading — because "the most productive learning that can happen with an AI coding tool is when it isn't used to generate much of any code at all." Meanwhile the trillion-dollar bet that this knowledge won't matter is, per David Cramer, "a science experiment" — and if the expertise pipeline dries up, Sam Altman's vision of selling intelligence back to us on a meter could become reality.
- [How I Find Problems to Solve as a Staff Engineer](https://lalitm.com/post/find-problems-staff-engineer/) — Finding problems worth working on isn't separate from the rest of the job: "I act like a sponge," absorbing problems from the day-to-day noise and letting them accumulate until the same issue surfaces across teams or several awkward requests collapse into a single shape. A common shape is only a hypothesis — "elegance is not evidence" — so I pressure-test it with a prototype, an RFC and other people, and drop it when people don't see the value or the timing is wrong. Solving useful problems pulls me into more conversations, which is how I find the next one.
- [Agent Design Is Still Hard](https://lucumr.pocoo.org/2025/11/21/agents-are-hard/) — Building agents is still messy: "SDK abstractions break once you hit real tool use," so drive the loop yourself against the platform SDKs, and manage caching explicitly because "context editing will automatically invalidate caches" anyway. Reinforcement ends up doing more heavy lifting than expected, failures need strict isolation (subagents that report back only success), shared state wants a file-system-like layer so tools don't become dead ends, and the output tool is surprisingly hard to steer — model choice still depends on the task, and testing and evals remain "the hardest problem here."
- [Babies born under sugar rationing grew into adults with lower cance...](https://theconversation.com/babies-born-under-sugar-rationing-grew-into-adults-with-lower-cancer-risk-289873) — A study of more than 64,000 people born in Britain between 1951 and 1956 exploits the fact that sugar rationing ended in September 1953 and consumption nearly doubled, so children born months apart had very different sugar exposure in the womb and early childhood. Those with more rationing across their first 1,000 days had lower incidence of breast, prostate, liver, rectal and lung cancer, with the effect strongest for liver cancer at around 69% lower, and longer telomeres equivalent to about 2.2 years of slower biological ageing. What is most surprising, the authors write, is that early-life sugar exposure still shaped diets 50 years later: people who experienced rationing ate less sugar and less overall as adults, suggesting a taste for less sweetness formed early and stuck.
- [Why some people mow a lawn better than others](https://pudding.cool/2026/06/mow/) — 30,954 people mowed the same lawn, and 16% found one of the 12 perfect solutions — but the surprise is that optimality held around 90% whether a lawn took 26 moves or 177, unlike the Traveling Salesman Problem that Coverage Path Planning is related to, because a lawn has structure where TSP scatters nodes randomly. People "decomposed" the lawn into smaller sections and "compressed" what they learned into a mental model, and the best mowers "spent their time at the forks and cruised through the rest" — time alone explains less than 5% of the variation in how people did, so it's not about thinking more or faster, but when thinking happens.
- [Prevent cognitive debt by manually retyping LLM-generated code — ...](https://ankursethi.com/blog/prevent-cognitive-debt-by-manually-retyping-llm-generated-code/) — Coding assistants are fine for fast-forwarding through the boring parts, but letting one roam free leaves "a colossal amount of cognitive debt," and poring over AI-generated PRs isn't fun either. So the fix is grossly inefficient and perhaps slightly comical: tell the agent to show every proposed edit in the chat, then type it all in manually, because "I value comprehension over productivity." Retyping forces you to slow down, catch hallucinations and bad design, and build a spatial map of your codebase — and "I can at least make sure I completely understand the software I put out into the world."
- [Use Task Runners for Common Coding Tasks - Ham Vocke](https://hamvocke.com/blog/task-runners/) — I switch between repos with different tech stacks all day, and I don't want to remember whether it's `rust fmt` or `mix deps.update`, or whether it was `yarn`, `npm` or `pnpm` after all these years — I want to just say "build the code", "lint it", "run migrations". So I make task runners: a simple bash script saved as `run` in the repo root, `make` contorted just a little (with `.PHONY` targets to stop it lazily refusing to run, plus free tab autocompletion), `just` (very familiar if you know Make, minus some of its weirder parts), or `mise`, which has grown into a developer's swiss army knife. This is not exactly rocket science — it's a small quality of life improvement, super simple to set up, and yet something I rarely see in the wild.
- [Devtools must be open source - exe.dev blog](https://blog.exe.dev/devtools-must-be-open-source) — Agents have collapsed the cost of personalizing software on two fronts at once — it's much easier to get started hacking in the feature you want, and much easier to keep going, because an agent can rebase your local changes on upstream nightly. The result is that "the software we live with is far more powerful with personalization. All you need is the source code" — plugin systems and config files were the old answer to pre-agent development costs, and "for end-user products to make sense in a company today, they need to be personalizable. Which means we need the source code." Hence the divergence: you can apply the same skill-based technique to open-source agents like Shelley and Pi ("the source code is the extension system"), but Claude Code is closed-source, so if how you want an agent to work doesn't fit in their hooks, switch to an agent that lets you personalize it.
- [Reading a Performance Profile: Field Guide](https://perf.reviews/profile-guide) — A field guide to reading the Chrome DevTools Performance panel: color encodes the kind of work, not the file, so "when one color dominates, that's usually the bottleneck." Work the workflow in order — "Capture like your users," scope Nav to LCP, read Summary then the Insights sidebar, sort Bottom-up by self time, walk the long tasks, cross-check the network, then "Verify the fix" — because a
- [The Building Block Economy](https://mitchellh.com/writing/building-block-economy) — The most effective way to build software and get massive adoption is no longer high quality mainline apps but "via building blocks that enable and encourage others to build quantity over quality" — because the factory of today is agentic, and AI is *really good* at gluing together high quality, well documented, and proven components, so the old barrier to entry is gone. The effects run both ways: imports are up (we're "more than ever before grabbing off the shelf components and gluing them together") and exports are up, with a lower quality bar, greater awareness of niche use cases, a lower maintenance burden, and outsourced R&D making the mainline application "more stable and more purposeful in its feature set." Closed source, commercial software apppears to be at a massive disadvantage since agents pick open and free alternatives, but he withholds a concrete answer there — "The point is the shift has already happened. We're living in it."
- [95 reasons for having your own website](https://bellkiosk.website/blog/reasons-to-website.html) — Ninety-five reasons for having your own website, from "to write for oneself," "to post quietly," and "to have a home on the open web" to "to keep the like counter at 0," "to bring guest books back," and "to recreate your old blogspot or tumblr" — a website as memory, prayer, protest, play, and "a form of care." Because "a website is just files & folders," the web is "still a largely unexplored artistic medium" worth claiming against "vibe coding" and the platforms: "do we need a reason to website?"
- [Never Enough](https://dark.ronacher.eu/2026/7/21/never-enough/) — Two recent stories about Silicon Valley are "hard to read without wondering if everyone involved has lost their mind": a couple earning a combined $550,000 who still feel behind, and a founder who has Claude review recordings of her first dates. People fear being replaced by machines and respond by giving those machines more of their judgment, attention and time — every "saved" hour returned to a race with no finish line. Maybe we need the misfits who know when to stop, who leave a conversation unrecorded, and who "find peace not by getting ahead, but by no longer needing to."
- [The Future Worth Building Is Human](https://thinkingmachines.ai/blog/the-future-worth-building-is-human/) — Thinking Machines' mission is "to build AI that extends human will and judgment" — because productive knowledge is tacit, local, and scattered across every shopkeeper and chef, intelligence alone only goes far in closed games like chess and math, and AI "must itself be distributed" to be shaped by the people it serves. So they train frontier models, build tools that let everyone fine-tune models with their unique knowledge, and make a long-term bet on interaction models that handle live, multimodal interaction natively, since "a small text box and a long wait" is too narrow a channel for human intent. Alignment, too, they treat as "a feature not of a single model but of an ecosystem of AIs raised in different places" — the current path frames participation vs. capability as a trade-off, but they see those as technical challenges to solve, and they "believe in keeping the weirdness alive."
- [Corners are relative](https://shedsgns.me/radius) — A border-radius is just a number, and roundness is relative: the same 12px reads generous on a button and almost flat on a card, so a system needs a scale for the outer radius and a rule that derives the inner one. "The inner radius is the parent's radius minus the full gap" — border and padding both — because "the formula gives you concentric, not finished," and at 4px concentric the eye often wants 6. With `corner-shape`, a squircle doesn't offset to a smaller squircle, so "the formula was always a floor, not a finish": there's no simple number that lands, so judge it, gate it behind `@supports`, and ship the least-wrong one.
- [A reading list for generalists — LessWrong](https://www.lesswrong.com/posts/sH4cFDDjRdGrn3p2o/a-reading-list-for-generalists) — "I, along with many others in AI safety, believe there is a shortage of generalists in the community," so the author assembled 18 documents — blog posts, a comment, an interview transcript, and a book — that personally helped him most, citing Paul Graham (5), Ben Kuhn (4), Ethan Perez (2), and Greg Brockman (2). The crux: "if you're working hard as a generalist on a project you care a lot about, then by rigorously applying the lessons from these documents you will improve more quickly than you otherwise would." They're grouped into dispositional ("Relentlessly Resourceful," "How to be more agentic"), strategy ("Humans are not automatically strategic" — the single item he'd recommend), project leadership, and interpersonal/organizational, with an open invitation for others to comment with pieces that should be on the list.
- [Engineering for Bounded Cognition](https://shapeofthesystem.com/posts/2026/02/03/bounded-cognition) — The mind that builds software is far smaller than the software it builds, and almost everything good in engineering is a way of living with that gap — "four slots, a narrow beam, and a leak." So the industry's beloved phrase "human error" is mostly a system built for an operator who never gets tired and never looks away; that operator was never born, and every system built for them is already broken. The central question isn't how to find a mind big enough to hold all of this, but how to shape the thing so that a small mind can work on it without bringing it all down — and designing for the most constrained user, whether a tired engineer or a model losing the thread, just gives you a better thing.
- [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) — Loop engineering is replacing yourself as the person who prompts the agent — you design a system that finds the work, hands it out, checks it, writes down what's done and then decides the next thing, and that "may be the future of how we work with coding agents." A loop needs five pieces (automations, worktrees, skills, plugins/connectors, sub-agents) plus a memory that lives on disk, because "the agent forgets, the repo doesnt." But the loop "changes the work, it does not delete you from it" — verification, comprehension debt and cognitive surrender all get sharper, so "build the loop, but build it like someone who intends to stay the engineer, not just the person who presses go."
- [Mechanical Watch – Bartosz Ciechanowski](https://ciechanow.ski/mechanical-watch/) — The movement is the star here: "beautiful watch cases merely hide the intricate mechanisms which are the real stars of the show," so over this article I explain the workings of the mechanism, and the purpose of each part, in draggable, color-coded demonstrations. A mechanical watch runs without batteries or electronics, and its timekeeping core is just seven major elements — a mainspring wound by an arbor inside a barrel, a train of gears whose ratios turn close to 7 barrel rotations into around 2,400 revolutions of the second hand, an escapement, and a balance wheel that "forms the beating heart of a watch." The rest fills in the practical details: mainplate and ruby jewel bearings, the click that keeps the mainspring from unwinding on its own, the motion works that drive minute and hour hands and the date, and the keyless works that let the crown wind and set them.
- [Building Glass for the Web](https://aave.com/design/building-glass-for-the-web) — Inspired by Apple's Liquid Glass, we brought our own version — Aave Glass — to the Aave App, and then set out to bring that same feeling to the web, where the demos going around only ran in Chromium via an SVG `backdrop-filter` approach or the experimental HTML-in-Canvas API. Our technique runs in every modern browser with no flags and no fallbacks, bending the real rendered content with a single SVG filter primitive, `feDisplacementMap`, so "text under the lens stays selectable and links stay clickable," and the same displacement map feeds a WebGL shader where there's no live DOM to filter, like a canvas-drawn QR code or a video Safari refuses to filter: "The renderer changes with the medium, the refraction stays the same." We built a family of components on it — switch, slider, toggle group, QR code, video player — and most of the work went into Safari's quirks: refreshing the filter with a fresh ID each update, computing only a quarter of the map for its four-fold symmetry, staying conservative about our footprint, and reading only a lens-sized region for the specular highlight.
- [React handbook](https://devouringdetails.com/resources/react-handbook) — A set of personal preferences for what makes a good React component: prop names shouldn't duplicate context already supplied by the component itself (`isOpen` on `Dialog`, not `isDialogOpen`), and before adding a boolean prop you should consider whether it can be derived from an existing one. Enum props "make impossible states impossible" where `isPrimary isSecondary` allows an impossible state, and composability — compound components like `DropdownMenu.Root` and `DropdownMenu.Item` — beats a `data` prop because you get control over every element rendered rather than passing in `separatorClassName` or `hasArrow`. "If you know what you're doing and other parts of your interface don't rely on this state," manipulating the DOM directly from a callback is more performant than high-frequency React updates that trigger a re-render.
- [How's Linear so fast? A technical breakdown](https://performance.dev/how-is-linear-so-fast-a-technical-breakdown) — There's no secret silver bullet to performance — Linear is fast because it was "built from the ground up on the right foundation, then improved by countless decisions," starting with the database living in the browser in IndexedDB and a sync engine where mutations apply locally first and reconcile in the background, since "UI responsiveness should not depend on network latency." The rest stacks on top: a first load that ships less code in more pieces with modulepreload and a service worker precaching the rest while the user sits on the login page, auth that renders first and authenticates second, a keyboard-first input model with a global command palette, and animations kept on the GPU with durations below the 100ms threshold. Take any one layer away and "the app starts to feel slow" — the speed is a property of the system, not of any single one.
- [Notes on software quality](https://anthonyhobday.com/blog/20260410) — Quality is “the absence of problems,” a spectrum up to a perfection that’s impossible, and it rests on the organisation — “~100% of the time I’ve seen an organisation make high quality software, it is because the leaders wanted it.” But quality gets harder with scale, and past a certain point it’s impossible: “this is a natural result of scale… It cannot be solved. It’s a trade-off.” In software the six signals are reliability, speed, clarity, efficacy, efficiency, and beauty — and though quality is ideal, “there are many ways to compete that cost less than quality.”
- [Output isn’t design - Linear](https://linear.app/now/output-isn-t-design) — Design keeps being misunderstood in our industry: new tools promise to generate interfaces faster or collapse design into code, but "the hard part of design is rarely generating the form" — it is understanding the problem well enough to know what and how something should exist at all. AI generates plausible outputs quickly but doesn't help you understand the underlying problem, which is why you see products that "look polished, ambitious, and impressive at first glance, but begin to unravel the moment you actually use them" — the form is there, the fit is not. Design still requires judgment, conversation, tension, and time, and "the core design is still about understanding, not output."
- [Train Your Judgement](https://emilkowal.ski/ui/train-your-judgement) — AI can write animation code, but what it can't do is know what feels *right* — it produces motion that works yet feels mediocre, and "if you can't tell the difference, you'll ship it." The article trains your ability to spot what's wrong, name it, and fix it through side-by-side exercises: pick the better animation, write down why you chose it, then see the breakdown, because putting into words why something feels right "trains your ability to articulate your judgment, a skill that will be incredibly valuable in the AI era."
- [Details That Make Interfaces Feel Better](https://jakub.kr/writing/details-that-make-interfaces-feel-better) — Great interfaces rarely come from a single thing — they're usually a collection of small things that compound into a great experience, so pair `text-wrap: balance` on titles with `text-wrap: pretty` on descriptions, set the outer radius equal to the inner radius plus the padding, and make animations interruptible, because when they aren't "it can make the interface feel broken." The rest of the list: animate icons contextually with `opacity`, `scale` and `blur`, antialias text so it renders thinner and crisper, use `tabular-nums` when digits shift, split and stagger entering elements, keep exits more subtle than enters, align optically instead of geometrically, use a subtle `box-shadow` instead of a border, and add a `1px` black or white outline at `10%` opacity to images.
- [Work on the Right Product | Yangshun Tay](https://www.yangshuntay.com/blog/work-on-the-right-product) — "The product you work on matters more than the title on your badge" — Tay sorts products on a complexity matrix (thin/thick client against thin/thick server) and says you want to be in the thick/thick quadrant, where both sides are doing serious work and "everyone here is solving hard problems." A frontend engineer on a server-heavy product converges toward "wiring up API responses to form fields" — integration work that kills growth because the gap in expertise "compounds" and the frontend team becomes a service team; the reverse makes a backend engineer a "glorified database proxy." So watch for the bait and switch of a backend team hiring one frontend engineer to "lead the frontend work," and ask "Where does the complexity live in this product?"
- [Thoughts on slowing the fuck down](https://mariozechner.at/posts/2026-03-25-thoughts-on-slowing-the-fuck-down/) — Everything is broken: agents make errors like humans do, but they don't learn and there's no human bottleneck to feel the pain, so tiny booboos compound into an unrecoverable mess of complexity—and agentic search has low recall, so the agents can't clean it up either. The move is to stop being lured by the sirens, scope agents to boring/evaluable/non-mission-critical work, stay the final quality gate, hand-write the architecture and API, limit how much code the clanker generates per day, and accept that "slowing the fuck down is the way to go."
- [Understanding easing and cubic-bezier curves in CSS](https://joshcollinsworth.com/blog/easing-curves) — Understanding easing curves—the "rhythm" of movement, each one just a line defined by four numeric values—matters because "well-designed movement makes a UI both more engaging *and* more intuitive," while bad transitions "can make the same UI feel mediocre, cheap, confusing, or even broken." The curve is shaped by two handles, the horizontal *x* axis is the duration and the vertical *y* axis the speed of change, and cubic-bezier is literally a function taking the start handle's coordinates then the end handle's. Movement tells a story: "the transition itself is the verb; the easing curve is the adverb."
- [Developing creative identity](https://michaelnotebook.com/dci/index.html) — I asked whether Darwin or Einstein were "writers", and taking that playful question seriously turns out to be a way to understand how new creative identities emerge — often from near-amateurs like Stewart Brand, whose "How Buildings Learn" develops a new kind of expertise in productive tension with the architects, and often by leaving existing communities and becoming "illegible even to oneself for a time". Brand, Darwin and Einstein illustrate different stages in how written forms, types of understanding and expert communities develop together, from amateur exploration to deep community of practice; Darwin sacrifices good story for truth and evidence, Brand writes-to-explore while Darwin writes-with-a-goal. Stories do something else — sometimes creating new states of consciousness, as in Ted Chiang's "Story of Your Life", the Bible as an identity for a people, or Robert Caro borrowing fiction's interiority — and forms like discovery fiction let the reader experience a result from the inside; there is no API for Hamlet.
- [Make What You Build Last](https://rene.wang/essay/make-what-your-build-last) — Everyone can ship things today, but most of what gets shipped cannot *survive* — and survival isn't about PMF or DAU. Since "simplicity does not mean faster progress. It means less surface area for decay," the move is to make better things rather than more, choosing OTP over password/OAuth because "once part of your thing breaks, the rest will rot much sooner." Then ship slowly: the products that get big and *stay* big "were patient," and "less hustle means less hype and more craft."
- [Boris Tane](https://boristane.com/blog/slop-creep-enshittification-of-software/) — Slop creep is the slow, invisible enshittification of a codebase: "death by a thousand reasonable decisions," where no single commit is the problem but the agent "introduced a slightly wrong abstraction, then built on top of it." Coding agents removed the old circuit breaker — they don't see the system, they see the prompt, so "the agent is confidently, competently wrong" and the reckoning is deferred and compounded. The answer is not to stop using agents but to own the one-way doors: "Spend more time in the plan. Write the code snippets for the decisions that matter. Then let the agent cook."
- [Laws of UX](https://www.userinterface.wiki/laws-of-ux) — The laws of UX I keep coming back to — Fitts's, Hick's, Miller's, Doherty, Postel's — aren't really about interfaces, they're about how people work: how we perceive time, make decisions, and hold things in our heads. Make things people need to click easy to click, disclose progressively instead of piling on choices, chunk data because it's "a cognitive necessity," keep interactions under 400ms (and if you can't make something fast, make it feel fast), and accept messy human input — "Validate generously, format strictly."
- [Writing a good CLAUDE.md](https://www.humanlayer.dev/blog/writing-a-good-claude-md) — Because LLMs are stateless functions — "The only thing that the model knows about your codebase is the tokens you put into it" — CLAUDE.md is the one file that goes into every single session, so use it to onboard Claude with your project's WHY, WHAT and HOW, and treat it as "the highest leverage point of the harness" rather than something to auto-generate with /init. Less is more: frontier thinking models follow roughly 150-200 instructions with Claude Code's own system prompt already burning ~50, and as instruction count rises, quality drops uniformly, so keep the file concise and universally applicable, ideally under 300 lines (HumanLayer's is less than sixty). Push task-specific detail into separate files via progressive disclosure — "prefer pointers to copies" — and never make Claude a linter, because "Never send an LLM to do a linter's job."
- [rate limiter – smudge.ai blog](https://smudge.ai/blog/ratelimit-algorithms) — A rate limiter "lets you control the rate of traffic that your service processes by blocking requests that exceed a set limit during a period of time," and this post walks through the three most common algorithms: fixed windows, sliding windows, and token buckets. Fixed windows are simple and predictable but "allow bursts up to 2x the limit when requests begin near the end of a window"; sliding windows "refill one request at a time" and are best done as the floating-window approximation (Upstash, Cloudflare) since storing every timestamp is resource-intensive. Token buckets hold a burst capacity and refill at a constant rate — Stripe's 500-token bucket refilling every 0.01s — and the post closes with the practical stuff: persist the store, fail open, choose sensible keys, and send 429s with useful `x-ratelimit-*` headers.
- [Behind the Sounds | Interface Craft](https://www.metaphorsound.com/bts/interface-craft) — "Sound is easy to overlook, especially in digital products, but I hope moments like these show how much it can add." The walkthrough breaks down three interface moments — the library card slot-in (a cork pop reversed and layered with swipe, a chime built from a resampled ping-pong drum loop, and a stamped-book recording), the scratch to reveal (a quarter scraped on gift cards, three variations cycled at random), and a last-minute Claude gift animation of a tonal pop, whoosh, and hit. The reveal chord re-voices the welcome chord from step one so it feels "familiar but still distinct."
- [I Hate Github Actions with Passion
…](https://xlii.space/eng/i-hate-github-actions-with-passion/) — I can't overstate how much I hate GitHub Actions — the road to hell started with a CUE-using build.rs that worked everywhere except Linux ARM, because the runner hides the x86_64 binary from the arm64 runner, and fixing it meant a 2-3 minute loop per single change through a heartless YAML-based system. The lesson, as the internet wisely puts it: "For the love of all that is holy, don't let GitHub Actions manage your logic. Keep your scripts under your own damn control and just make the Actions call them!" So I deleted build.rs, moved generation into a GNU Makefile, committed the files, and dodged the bullet early — we are all doomed to GitHub Actions.
- [Taste for Makers](https://paulgraham.com/taste.html) — Saying taste is just personal preference is a good way to prevent disputes, but it isn't true — if it were, there'd be no way to get better at your job, and "the recipe for great work is: very exacting taste, plus the ability to gratify it." Once you admit there's such a thing as good and bad design, the same principles of beauty crop up again and again across fields: good design is simple, timeless, solves the right problem, suggestive, often slightly funny, hard, looks easy, uses symmetry, resembles nature, is redesign, can copy, is often strange, happens in chunks, and is often daring.
- [AI Browser Security: Prompt Injection & Containment](https://www.browserbase.com/blog/ai-browser-prompt-injection-containment-security) — Prompt injection is "what happens when untrusted content becomes instructions," and in browser agents it means the model does something wrong — exfiltrating cookies, keys, and session data — because "every webpage an agent visits is a potential vector for attack." Vendors keep patching it, but it's a cat vs mouse game where "the success rate is low, but still non-zero," so the mitigation that scales is containment: each session in a dedicated VM, network-isolated, killed and recreated after use, with Stagehand positioned as "safe, deterministic automation." You can't patch the web — keep the scope of damage small when (not if) it tries to talk your agent into going rogue.
- [The Final Bottleneck](https://lucumr.pocoo.org/2026/2/13/the-final-bottleneck/) — Writing code used to be slower than reviewing it, but the bottleneck has moved downstream, and what's upstream now is an accumulating failure: OpenClaw has "north of 2,500 pull requests open," and "if input grows faster than throughput, you have an accumulating failure." The options are to throttle inflow — like Pi, which auto-closes PRs unless people are trusted — or to give in, letting machines review machines while humans "rubber stamp in the morning," which drifts toward "single-use plastic software" where responsibility moves from the individual to the factory. But "Non-sentient machines will never be able to carry responsibility," and as the author puts it: "Two years ago, I too was the bottleneck. I was the bottleneck all along."
- [Novelty](https://rauno.me/craft/novelty) — Novelty is the contrast to sameness: the more commonly an action is performed, the less rewarding any novel visual or motion treatment becomes, so make 90% of the experience familiar and 10% novel, and use it where intent supports it because a novelty tax can overwhelm people. "Make most things familiar, do something unexpected."
- [Shades of Halftone - The Blog of Maxime Heckel](https://blog.maximeheckel.com/posts/shades-of-halftone/) — Halftone went from a printing workaround to a democratized artistic tool, and this article breaks it down from its most fundamental pieces — "the first step is, as you may expect, to render a single dot or circle using GLSL and UV coordinates" — up through a grid of dots built with `fract`, applied as a filter over images, video, and React Three Fiber scenes. It then walks the variants: luma-driven radii, staggered offset grids, white-dot and ring patterns, and finally multichannel halftoning, where CMYK layers are rotated at preset angles (15, 75, 0, 45) to keep Moiré interferences to a minimum and subtractive blending reproduces "the optical mixing found in physical print" — "we're jumping through a lot of hoops here, going from RGB to CMYK to emulate back RGB through subtractive blending, just to get a specific look and feel." Breaking the grid comes last: sampling a 3x3 neighborhood so dots leak past the cell wall, `smoothmin` merging neighbors into gooey ink, and a MouseTrail-driven displacement, before teasing a future article on real-time shader-based paintings like impressionism, pointillism, and watercolor.
- [Notes on The Crux](https://lethain.com/notes-on-the-crux/) — Will Larson reads Richard Rumelt's *The Crux* and finds it "quite good," doing a better job than *Good Strategy, Bad Strategy* of concisely landing the problem areas to avoid — most prominently, "Don't start with goals–start by understanding the challenge and finding its crux" and "Don't Confuse Current Financial Results with Strategy." He still recommends *Good Strategy, Bad Strategy* first for anyone trying to deploy strategy in their own environment, and the biggest idea that stood out for him is "the tension between executives needing to prioritize working the Crux with the entirety of managing the team and business around them." Along the way he works out his own distinction between Rumelt's challenge-based strategy and his own constraint-based view of engineering strategy, and why "creation 'in committee' is exceptionally difficult."
- [A React trick to improve exit animations](https://barvian.me/react-exit-animations) — React batches the updates that close a popover with updates that change the exiting component's contents, and "if it updates at the same time it draws attention to itself." Saving state or delaying updates (like Base UI's `onOpenChangeComplete`) is either too burdensome or "can get a bit complex when handling interruptions to the exit animations" — so he wraps React's own Suspense, which renders suspended subtrees without committing their DOM changes, and uses a Fragment ref to undo the `display: none !important` it applies. It's "obviously a bit of a trick" that could break in a future React, though it works in 18 & 19.2, and he hopes the React team adds an Activity mode for "visible and inactive" content.
- [How to Research Anything](https://www.polymathinvestor.com/p/how-to-research-anything) — You can pursue genuine intellectual curiosity with a full-time job and scattered hours — the constraint isn't credentials or time, it's knowing how to scope questions, extract maximum value from minimum reading, and build knowledge that compounds. Reframe big curiosities into specific, answerable questions, start with the end in mind, favor long-half-life content over clickbait, and read in layers so "important details get multiple passes; filler gets one or none." Then write it down or lose it, synthesize across domains by finding patterns and translating concepts between contexts, and define "done" at the start, because more information has diminishing returns and time is better spent synthesizing than hunting for marginal gains.
- [Building Bulletproof React Components - Shu Ding](https://shud.in/thoughts/build-bulletproof-react-components) — Most components are built for the happy path — they work until they don't, because "the real world is hostile": server rendering, hydration, multiple instances, concurrent rendering, async children, portals. The real test isn't whether your component works on your current page, it's whether it works when someone else uses it in conditions you didn't plan for, so each step hardens a theme provider — server-proof, hydration-proof, instance-proof, concurrent-proof, composition-proof, portal-proof, transition-proof, activity-proof, leak-proof, future-proof. "These aren't edge cases. They're the new normal."
- [Outsourcing thinking
 – Erik Johannes Husom](https://erikjohannes.no/posts/20260130-outsourcing-thinking/index.html) — Yes, "thinking often leads to more things to think about," but there is "another fallacy at play here, which is that 'it does not matter what we think about, as long as we think about *something*'" — and the boring, tedious cognitive tasks we hand over still shape us, because "acquiring and memorizing knowledge is a huge part of learning to use the knowledge." Personal communication is deceptive to fake since "it's impossible to separate the meaning from the expression of it," and even automating project administration "will rob me of the opportunity to feel ownership to the project" — so how we use chatbots "is not only about efficiency and cognitive consequences; it's about how we want our lives and society to be."
- [Two kinds of AI users are emerging. The gap between them is astonis...](https://martinalderson.com/posts/two-kinds-of-ai-users-are-emerging/) — There are two kinds of AI users now: "power users," all in on Claude Code, MCPs and skills — "Surprisingly, these people are often *not very technical*" — and everyone else, still just chatting to ChatGPT. Enterprise IT policy explains much of the gap: locked-down environments plus Microsoft Copilot, which "feels like a poorly cloned version of the (already not great) ChatGPT interface," so that "this is becoming an existential risk for many enterprises" while smaller companies without the baggage are "*absolutely flying*" with AI. The bifurcation is real and "speeding up dramatically," with the real leaps made organically by employees who know the process inside out rather than by top-down AI strategy.
- [The Value of Things – journal.stuffwithstuff.com](https://journal.stuffwithstuff.com/2026/01/24/the-value-of-things/) — Generative AI "can be an amazing tool for creating things with utility faster and more easily than you ever could before. But it can't generate meaning" — because meaning comes from spending an irreplaceable fraction of your life making something for someone else, and "by making us more productive, AI eliminates meaning." So the call is: use AI where utility is what matters, "and when I'm making something where the human connection and meaning are important, I will try to put as much of myself and as little of the machine into it as I can."
- [Generating Sounds with AI](https://www.userinterface.wiki/generating-sounds-with-ai) — The author knows what sounds he likes but isn't a sound engineer, so he funneled the "extremely dense and kind of a bore to read through" Web Audio API docs into Cursor and started conversing with it — describing what he wanted and what sounded wrong until he got a click he actually liked, learning along the way that filtering `noise` with a `bandpass` filter "keeps only a specific range of frequencies, which is what makes it sound like a click," and that "real sounds don't just stop, they decay," so envelopes split into attack and decay. From there he built out a whole library: "It's crazy that with zero knowledge of audio synthesis, I was able to come up with a library of sounds that feel pretty good" — sounds he understands and can tweak instead of random files he downloaded. "The process was collaborative. I provided taste and AI provided implementation. Neither of us could have done it alone."
- [Some Fun Software Facts](https://buttondown.com/hillelwayne/archive/some-fun-software-facts/) — The newsletter closes out the year with “something light”: "some random fun facts I accumulated about software over the years." Among them: a team of eight+ programmers implemented Tetris as a Conway's Game of Life simulation spanning 30 trillion pixels with a full programmable CPU, Vim is Turing complete, “most implementations of mergesort pre-2006 were broken,” PDF's drawing model cannot render perfect circles, and JSFuck encodes any valid JavaScript program using just `()+[]!`. Things have changed, too — Google Sheets treats 1900 as a normal year, and in 2020 biologists renamed 27 genes because Excel kept parsing them as dates.
- [Unhappiness is a choice](https://andrewconner.com/the-option-method/) — The Option Method, created by Bruce Di Marsico in the 1970s, holds that unhappiness is never necessary — it is always optional, and you create it yourself by believing it is necessary in certain circumstances: "In short, you are unhappy because you think you should be." Change the belief and the unhappiness evaporates, even if the circumstance remains exactly the same, because the real cause is never the external event but the belief that the event means you must be unhappy. The goal is not to judge yourself for being unhappy, but to realize at a deep, experiential level that you are the active creator of your unhappiness — for good reasons! — and therefore have the power to let it go.
- [If you are good at code review, you will be good at using AI agents](https://www.seangoedecke.com/ai-agents-and-code-review/) — Using AI agents correctly is a process of *reviewing code*: if you’re good at code review, you’ll be good at using tools like Claude Code, Codex, or Copilot. The key is structural review — “only thinking about the code that was written, not the code that *could have been* written” — because agents will otherwise spend a lot of effort committing to bad design decisions, while nitpicky reviewers tweak lines and rubber-stamp reviewers trust too much. The dominant model is “centaur chess”: a skilled human paired with a computer assistant.
- [MCP, Skills, and Agents](https://cra.mr/mcp-skills-and-agents) — Skills, tools, MCP, subagents and commands all look pretty similar, but the difference "is really about the way they do it" — MCP is "simply a way to expose new tools", while skills "give agents… new skills. It's in the name!" Subagents are "the ignored opportunity", commands "are dead in my opinion", and the real problem is the "X is all you need" thinking, since both skills and MCP used incorrectly "will cause context pollution in your harness" — so go try skills and some *good* MCP servers, "you'll find that both have a place and offer value."
- [Reverse engineering Lyft bikes for fun (and profit?)](https://ilanbigio.com/blog/lyft-bikes.html) — I spent a month reverse engineering Lyft's private API — MitM-ing my iPhone's encrypted traffic through Charles Proxy, replaying the `rent` endpoint with spoofed `userLocation` coordinates, then `aiohttp`-ing all 10,000 bike IDs in ~15 seconds at ~650 RPS (which looked enough like a DoS that Lyft filed a sev, my intern friend tipped me off, and I filed a HackerOne report). The win was that an attacker could unlock more than one bike at a station — probably a race condition — and Lyft made an exception to their no-brute-force rule to pay me $500. "Curiosity and determination are unreasonably effective, and seem to create luck," so: "Go reverse engineer something. Just, be nice about it."
- [frameworks for understanding databases](https://www.bitsxpages.com/p/frameworks-for-understanding-databases) — All databases have one purpose: to store data so you can retrieve it. This intro post for engineers who want to learn how these systems work underneath the hood lays out a mental model for evaluating tradeoffs across performance (read, write and space amplification, RUM, indexes, data orientation, compaction/GC), availability (PACELC, deployment architecture), and durability (LCD, storage options, WALs), before deep dives on the nine types.
- [The challenges of soft delete](https://atlas9.dev/blog/soft-delete.html) — Adding an `archived_at` column "seems to ooze complexity out into queries, operations, and applications" — applications must always avoid the archived data sitting next to live data, indexes and migrations get messier, backups take longer to restore, and "99% of archived records are never going to be read." He's not a fan of soft delete via `archived_at`, and would reach first for a trigger-based approach that copies deleted rows into a separate archive table (JSONB blobs, optionally tracking `caused_by_table`/`caused_by_id` through cascades), with application-level events and WAL-based CDC via Debezium/pgstream/wal2json as the alternatives — all of which keep live tables clean at the cost of extra infrastructure, and, for CDC, real risk to primary stability if `max_slot_wal_keep_size` and replication slot lag aren't monitored.
- [How to write a great agents.md: Lessons from over 2,500 repositories](https://github.blog/ai-and-ml/github-copilot/how-to-write-a-great-agents-md-lessons-from-over-2500-repositories/) — Most agents.md files fail because they're too vague — "You are a helpful coding assistant" doesn't work, but "You are a test engineer who writes tests for React components, follows these examples, and never modifies source code" does. An analysis of over 2,500 agents.md files across public repos shows the best-performing ones give a specific persona, put executable commands early, show code examples over explanations, set clear boundaries ("Never commit secrets" was the most common helpful constraint), name the exact stack with versions, and cover six core areas: commands, testing, project structure, code style, git workflow, and boundaries. "The best agent files grow through iteration, not upfront planning."
- [Benchmarking AI Agent Memory: Is a Filesystem All You Need?  | Letta](https://www.letta.com/blog/benchmarking-ai-agent-memory/) — Letta put a LoCoMo conversational history into a plain file and let a GPT-4o mini agent search it with filesystem tools like `grep` and `open`, hitting 74.0% — "significantly above Mem0's reported 68.5% score for their top-performing graph variant." The argument: "it's much more important to consider whether an agent will be able to effectively use a retrieval tool (knowing when and how to call it) rather than focusing on the exact retrieval mechanisms," since simpler tools are more likely to be in an agent's training data. Comparing frameworks and memory tools is "like comparing apples to oranges" — the Letta Memory Benchmark and Terminal-Bench are offered as the apples-to-apples alternatives.
- [Move Over, ChatGPT](https://www.theatlantic.com/technology/2026/01/claude-code-ai-hype/685617/) — Claude Code is the Anthropic tool that has Silicon Valley spending its winter break with it because, unlike ChatGPT, it actually does things — "It just DOES stuff," as one convert texted, whether that's booking theater tickets, ordering DoorDash, or replicating a Stanford political scientist's mail-in-voting paper in an hour. The argument is that this is bigger than the ChatGPT moment: "a win for the AI world" after a season of slop, and possibly an inflection point toward recursive self-improvement and the job disruption that would follow. It hasn't reached the rest of the world yet — it's intimidating to set up, the cheapest version costs $20 a month — and as Kelsey Piper puts it, 99 percent of the time it's a tireless magical genius, 1 percent of the time it's a puppy peeing on your couch.
- [How we migrated our database to PlanetScale](https://buttondown.com/blog/how-we-migrated-our-database-to-planetscale) — Buttondown migrated its ~2TB core Postgres database off RDS to a PlanetScale Metal instance after logical replication and AWS DMS both proved too slow, landing on pgcopydb (patched in their own fork for bugs that parsed 'null' as a literal null and duplicated single quotes), which copied the data in about 7 hours. "Overall, we're happy to have migrated to PlanetScale." PlanetScale's Insights tab has already led to indexes and query changes that cut automation queueing latency 100x (p50 of 100ms to 1ms) and make bulk actions and the internal admin tool noticeably faster.
- [Give your agent a laboratory, not a task](https://brianlovin.com/writing/give-your-agent-a-laboratory) — Coding agents are only as good as their feedback loop, so "you must give your agent the ability to view and verify its own work" — and if it ever asks you to do something manually, stop and think really hard about how to give it the tools to do the thing by itself. Vague asks like "make it faster" or "implement this design" make for lazy agents that fix one thing and break another, so the examples reorient the mental model: for performance, have the agent build itself a laboratory of instrumentation, diagnosis, iteration, and an HTML before/after report; for a Figma design, make it pull the source, build a wrong first pass, then loop screenshot-compare-fix "until you can't find any differences," because "the gap between 'close enough' and 'correct' is where polish lives." The notes add that verbose prompting will decline as models improve, not every prompt needs this much scaffolding, and you should encode a proven workflow into a skill only after you've built up model feel.
- [Paper - App Stacks](https://appstacks.club/paper) — Paper is "a browser-based design tool focused on the early, exploratory phase of design," built on the belief that "design and engineering are different jobs" and that tools introducing coding or responsive constraints too early "can actually be harmful in that early part of the process." Under the hood, Stephen Haney's team builds most things from scratch because performance is critical — chasing an 8 millisecond frame budget, bailing out of React into vanilla JavaScript, using MobX for selective state updates, Bun and Hono on the backend, MongoDB as the document store, and a self-built WebSocket multiplayer layer on Fly.io and Cloudflare. Shaders are written by hand — "we don't use AI for shaders because it's not very good at that yet" — and because everything renders through React, you can copy the code that's running and paste it into Framer or your own app.
- [Database Transactions — PlanetScale](https://planetscale.com/blog/database-transactions) — Transactions are "a sequence of actions that we want to perform on a database as a single, atomic operation" — you `begin;`, run your queries, and `commit;` to apply them all or `rollback;` to undo them. Postgres and MySQL both deliver consistent reads but in totally different ways: Postgres multi-versions rows (tracking `xmin`/`xmax`, then `VACUUM FULL` to reclaim the duplicates), while MySQL overwrites rows immediately and reconstructs past versions on the fly from an undo log. From there it maps the four isolation levels — Serializable, Repeatable Read, Read Committed, Read Uncommitted — against the phenomena they allow (phantom, non-repeatable, and dirty reads) and shows how concurrent writes resolve: MySQL locks rows and can deadlock, Postgres uses predicate locks and optimistic conflict resolution, and since both will kill a transaction to hold SERIALIZABLE guarantees, "Applications must account for this outcome, and have retry logic for important transactions."
- [Just Fucking Use Effect](https://justfuckinguseeffect.dev/) — Just fucking use Effect: errors are *values*, not try-catch prayers, and you get retries, timeouts, interruption, resource cleanup and built-in tracing —
- [Behind scenes](https://devouringdetails.com/resources/behind-scenes) — Devouring Details is an interactive reference manual for interaction-curious designers, and this behind the scenes shares tidbits from the creative process: the alliteration naming strategy, building a custom platform, video placeholders, bespoke iconography, the moodboard, and platform ergonomics. To *devour details* means to be fanatically obsessed with imbuing every aspect of your work with care — and the obsessive technique is the argument: "Prototypes are far more effective at communicating detail than videos." It's not a course in the sense that it is not linearly progressive — you won't solve code challenges, answer quizzes, or follow a tutorial to build something end-to-end; instead you interact with prototypes and get exposed to details I pay attention to.

## Publications

- [The Pudding](https://pudding.cool/) — The Pudding is a running series of numbered visual data stories "about just about everything" — #225 asks "life after death?" in "a room of thousands of humans wrestling with what comes after it all," #224 wonders why some people mow a lawn better than others, and #220 invites you to explore 5,000 historic restaurant menus. Each entry lands with a number and a month, and there's a mailbox sticker for the ask: "Get The Pudding in your inbox."
- [Nautilus | Science Connected](https://nautil.us/) — Nautilus is Science Connected, publishing stories like “Leap Seconds Have Helped Keep Clocks Synchronized with Earth’s Rotation, But Their Time May Be Over” and “The Key to Multilingualism Lies in the Ears, Not the Mouth.” It also offers a newest print issue, “The Stupid Issue,” and latest stories filed under History, Biology, Arts, Math, and Communication.
- [Readwise](https://wise.readwise.io/) — Wisereads is "a new newsletter by Readwise," published weekly as numbered volumes (now past Vol. 163), each pairing a book — How to Live a Meaningful Life, Bullshit Jobs, Moby Dick — with outside reading like "Ayman Nadeem on the death of 'plan mode.'" The archive runs from Vol. 1 through Vol. 163 plus a Wisereads Special Edition Vol. 1, with no editors or subscription details shown on the page.
- [Cold Takes](https://www.cold-takes.com/) — Cold Takes is a publication of "mostly long-form, mostly text" posts, ranging from "The Most Important Century (in a nutshell)" to "Where's Today's Beethoven?" and "Visualizing Utopia." Posts are stamped with dates and read times, with reader surveys and beta reader calls mixed in. "Good job opportunities for helping with the most important century" sits alongside "Cold Links" roundups.
- [Are.na Editorial](https://www.are.na/editorial) — Are.na Editorial is "Essays, interviews, and other forms of writing from and about the Are.na community." The page as it stands is placeholder scaffolding: every entry is labeled "Essay" with the same "An Example Post Title," a lorem ipsum body, a date of January 1, 0000, and the byline "Example Author" — no real posts, editors, or subscription details shown.
- [The Creative Independent](https://thecreativeindependent.com/) — The Creative Independent gathers interviews, essays, notes, and guides drawn from working artists — "Musician Le Ren (Lauren Spear) on learning while you create," "Essay: Creativity as resistance," "Guide: How to host a poetry workshop" — filed under themes like Adversity, Beginnings, Creative anxiety, and Failure, disciplines from Writing and Music to Curation and Games, in French, German, Japanese, Korean, Portuguese, and Spanish. The contributors are the people doing the work: musicians, painters, filmmakers, novelists, comics artists, chefs, perfumers, choreographers, designers, and comedians.
- [Letters to a Young Creator](https://letters.stevejobsarchive.com/) — The Steve Jobs Archive presents Letters to a Young Creator, a series that opens with a "SERIES INTRODUCTION" and runs letters stamped by city and date, from "LOS ANGELES, CALIFORNIA, USA August 26, 2024" through "LOS ANGELES, CALIFORNIA, USA November 10, 2025." No editor, writer, cadence, or subscription details appear on the page.
- [ui.wiki](https://www.userinterface.wiki/) — ui.wiki is a publication of Raphael Salaja's writing about interface craft — "There's a set of psychological principles behind every interface that feels right." Posts range from "Sounds on The Web" and "Morphing Icons" to "Mastering Animate Presence" and "12 Principles of Animation," with dates from Apr 8, 2025 through Feb 9, 2026. No subscription or cadence details appear on the page.
- [System Design Classroom | Raul Junco | Substack](https://newsletter.systemdesignclassroom.com/) — System Design Classroom is "A System Design Newsletter to help you build better software," written by Raul Junco. Its latest post is "AI Agents Just Rediscovered the Dual-Write Problem" — "The distributed-systems failure hiding between agent state and the real world" — dated Sep 26.
- [LessWrong](https://www.lesswrong.com/) — LessWrong's front page collects recent posts — under tabs for Recent, Enriched and Recommended — writing about frontier labs and AI safety, from "I believe we were fired for prioritizing safety over the near-term interests of OpenAI as a corporation" to essays on unfixable security vulnerabilities and CeSIA's just-launched "Politicians on AI" tool that "collects and classifies in detail what politicians have said about AI in recent years." The page itself names no editor, schedule, or subscription details.
- [Hello, World! System Design Newsletter](https://hw.glich.co/) — Hello, World! is a system design newsletter that says "Learn System Design every Monday" and "Read what engineers from Google, Microsoft, and Amazon are reading." Its featured and latest posts run from beginner explainers like "What is Redis Cache and Database?" and "What is an API?" to engineering deep dives such as "How DeepSeek Runs 380,000 Agent Sandboxes at Once," alongside link roundups like "Netflix Flinks & Shopify buys TailwindCSS." Rohit Lakhotia writes most of the posts, with Aniket Rawat credited on the news roundups.
- [Better Dev Link - On becoming a better programmer](https://betterdev.link/) — BetterDev Link is a curated issue-by-issue roundup where "I tried my best to not skip any issue," each one running through engineering reads — transformer explainers, floating-point error, Postgres row locks, Linux readahead — before a Tools section and a Self Hosted section. SerpApi "has been BetterDev's main sponsor for the last few weeks," and if you enjoy it, "please spread the word by sharing it with your friends," tweet about it, or buy a coffee.
- [Programming Digest: Email Newsletter](https://programmingdigest.net/?utm_source=twitter&utm_medium=cpc&utm_campaign=default_202209&twclid=2-4esldqj3n7d5l87xl4yghpmjk) — A carefully curated weekly newsletter for software engineers — "Join over 20,606 software engineers for one weekly email." Read handpicked articles with short summaries, save time on finding worthwhile content, and "Learn something new every week," from Jakub Chodounský.
- [Brain Food Newsletter](https://fs.blog/newsletter/) — Brain Food promises "timeless insights into business and life in 5 minutes a week. For free," pitched as "Noise-cancelling headphones for the internet." It lands every Sunday for over 1 million people, with "No spam. No politics. Just ideas and insights you can use."
- [Computers Are Bad](https://computer.rip/) — *Computers Are Bad* is "a newsletter on the history of the computer and communications industry (and sometimes something else)," thrown "directly at your doorstep on a semi-regular schedule, to enlighten you as to why computers are *that way.*" It's written by a DevOps consultant in Albuquerque, New Mexico who does his best to stay away from his areas of professional qualification, favoring "mid-century telecommunications history, legacies of the Cold War, and the rise and fall of the technology industry's stranger bit players." You can read it on the information superhighway, subscribe to keep the neighborhood paperboy pedaling, take the RSS feed, request fax delivery, or support on Ko-Fi, where monthly supporters get "eyes only," a "lower effort and higher sass" bonus edition of topics that don't quite make it to a full article.

## People

- [The DESK Magazine](https://vanschneider.com/blog/) — The DESK Magazine is a dated feed of short essays — "The new age of software," "Beautiful mistakes," "Every choice is a confession," "Death by a Thousand Buttons," "3 lessons from Jony Ive," "How to think for yourself" — most running 2 to 7 minutes, with a few flagged "Members only." It ends at Page 1 of 14 · 666 entries, with pieces on design, AI, quality, Japanese letterforms, and mymind.
- [Hugo Richard](https://hugorcd.com/) — Hugo Richard is a "Software Engineer & *Designer* at Vercel," where he says he's "Working every day to make the world a little better, or at least a few people's lives a little simpler." Before that he was a Software Engineer at NuxtLabs (2025) and did Freelance Design & Development from 2019 to 2024, and he writes about redrawing his portfolio, how he works with agents, and shipping the latest Nuxt stack with Docker. The page lists a Contact section, though no links are shown in it.
- [Adam Hutchinson | Adam Hutchinson](https://adjohu.com/) — I'm Adam Hutchinson — "I build things, write about things that catch my interest, and spend a lot of time outdoors." I'm building product at [Linear](https://linear.app/) and working on AI beings at [Plural Matter](https://pluralmatter.com/), and I write essays like "Throw away your code," "Simplicity is invisible," and "The curse of taste."
- [Noé Chagué](https://noechague.com/) — I'm a design engineer at Bitstack, "where we're building the easiest way to save and invest in bitcoin," and I think of craft as systemic, "because the quality of a product is the quality of the decisions it makes easy." I also co-founded Lyse, an open-source lab building tools to make design systems better, and previously worked at Finary — you can reach me on Twitter or see my code on GitHub.
- [Evan Conrad | Making supercomputers.](https://evanjconrad.com/) — Evan Conrad's site is titled “Making supercomputers,” and it's a blog. It lists posts including “The end of startups,” “How to make LLMs say true things,” and “How to reach Evan Conrad,” a guide to contacting him.
- [joonas.wtf](https://www.joonas.wtf/)
- [mamuso - manuel muñoz solera](https://mamuso.dev/) — A designer from Villena, Alicante, "based in beautiful California, building fun things at SpaceXAI" — with photography as his longest-running hobby and guitar a close second. The "Having fun" list is UnicodeKit ("Browsing characters like it's 1988"), Stray characters ("Typography is everywhere"), Papercups ("My favorite compostable goods"), a Figma Orgchart plugin, and GitHub Actions for discussions-to-Markdown, weekly updates, Figma-to-website, and closing Figma tabs.
- [Essays by Maggie Appleton](https://maggieappleton.com/essays) — Essays by Maggie Appleton collects her writing, from 'A Treatise on AI Chatbots Undermining the Enlightenment' and 'Growing a Human: The First 30 Weeks' to 'Why You Own an iPad and Still Can't Draw,' 'The Dark Forest and Generative AI,' 'Tools for Thought as Cultural Practices, not Computational Objects,' and 'A Brief History & Ethos of the Digital Garden' - 'A newly revived philosophy for publishing personal knowledge on the web.' No socials or contact are shown.
- [Articless — Written by Marv](https://articless-web.vercel.app/) — Articless is written by Designguymarv — "Have fun reading Articless by Designguymarv." The cards run from "AI & Design: A shift in how we design" and "Designing Articless: A thought process on articless" to "Design Thinking: Design better interfaces," "The Basics: Improving quality & taste," "Typography: The beauty of design," and "Simple Interfaces: Hide complex thinking." No socials or contact shown.
- [Personal website | Alex Harri Jónsson](https://alexharri.com/) — "Hey, I'm Alex. I'm super interested in software and design. I've been writing about software-related topics since 2019." His popular posts include "ASCII characters are not pixels: a deep dive into ASCII rendering" (using shape vectors for sharp, high-quality rendering), "A flowing WebGL gradient, deconstructed," "The web's clipboard, and how it stores data of different types," "Compressing Icelandic name declension patterns into a 3.27 kB trie," "Planes in 3D space," "Why doesn't TypeScript properly type Object.keys?" and "The Engineering behind Figma's Vector Networks." You can find his writing on /blog and learn about him on his /about page.
- [Articles](https://justinjackson.ca/articles) — "Hi, I'm Justin. These are my articles." His archive ranges across bootstrapping, SaaS marketing, and product advice — "Track revenue, not traffic," "Do the hardest thing," "AI isn't going to replace you" — plus recent pieces on Claude Code, podcasting, and his yearly reviews. No contact or social links appear on this page.
- [Diana Lu Portfolio](https://diana.lu/) — Diana Lu is an interaction designer based in LA — "this is an exhibition of her works:DDD" — from "AI Is Smart Enough, Let's Just Point and Talk to it;)" and Bring Fun to Everyday Digital Products to TikTok Intern, Hyper Online, OKDive, Yotype, Magic, and kinetic typography narrating "Begin Again." "Diana Lu is a designer. She does interaction and product design to bring joy:D" — she's currently studying at ArtCenter College of Design 🟠, identifies as a "former child," and is open to work: "if you find my projects interesting, contact me anytime:D." A resume is downloadable, and she loves games, hiking, skiing, and free diving.
- [Kian Bazarjani](https://bazza.dev/) — 'Crafting beautiful, modern interfaces for the web': I work as a design engineer at Navattic, partner with startups through my design studio Bazza Labs, and am building bazza/ui as my vision for interface excellence. Connect via Mail, GitHub, LinkedIn, or Book a call; my career also lists National Defence as DevSecOps Lead Architect and Software Developer, plus Summation, Fused, and Profound.
- [Jakub Krehel](https://jakub.kr/) — I'm a founding design engineer at Interfere, "where we're building the self-healing layer of the internet" — I care deeply about craft and quality and "I like to make people feel something through my work," having previously worked at OpenSea. You can reach me at @jakubkrehel, via email, or see my code on GitHub. My writing runs from "Details that make interfaces feel better" to gestures in Motion and "What are OKLCH colors?"
- [About | Marijana Pavlinić](https://marijanapav.com/) — Marijana Pavlinić is a Brand Designer at Vercel — "working across brand, web, and code in the devtools space" — who was previously at LiveKit and Supabase, where she "helped shape their brand and websites as they grew, which pulled me deeper into frontend and actually building what I design." Based in Croatia, she co-runs Buka Studio with her partner ("and a cat who rarely skips meetings"), and her latest side-project is cfntd.site, "a small coffee archive for specialty coffee enthusiasts—keeping track of roasters, beans, and brews in one place. Still brewing." The site also holds her Digital Stamp Collection, "paying homage to my grandpa's lifelong passion for philately, by recreating his stamps in a digital form."
- [Sujan Khadgi — Product Designer](https://www.sujankhadgi.com/) — This page is just a name and a role: "Sujan Khadgi — Product Designer." No bio, no notable work, no socials or contact details appear on it.
- [👋 Hi. I'm Sam.](https://samwho.dev/) — I'm Sam — "Husband, dad, programmer, whisky-drinker, writer" — and I write visual, interactive essays about software, each taking one to three months and covering material bottom-up from the simplest example. I also write posts like this in my full-time job as a developer educator at ngrok, and I only use my newsletter to announce new essays, so it only gets a few emails per year.
- [Portfolio of Work | Nivedha Nirmal](https://nivedhanirmal.com/) — Nivedha Nirmal is a "multidisciplinary designer" who is "Designing for the future of tech, lifestyle and experience with Project Inside Out, a creative design studio." The portfolio groups work under Brands, Spaces and Stories, and says she's "Taking up projects" via a work-with-me page.
- [Udara Jay](https://udara.io/) — Udara Jay's site is a running index of essays and notes — on making a world, proactive AI, affordance, virtual cells, the augmented thinker, memory for AI, bioinformatics, homelab servers, design engineering, phyllotactic patterns, timekeeping, sleep — alongside a microblog and open-source work. From the microblog: "Two years into the game I've been working on– a living sandbox shaped by deep simulation and a world that renders and evolves around you." The open-source list includes Tiny router ("Compact multi-head routing classifier"), Pile ("Reflective journaling app") and Stats ("A self-hosted analytics provider") on GitHub.
- [Edvins Antonovs](https://edvins.io/) — I'm a Senior Front-End Engineer specialising in React, TypeScript, frontend architecture, design systems, developer experience, and product engineering, based in Riga, Latvia, where "I build side projects, explore new stuff, and write about code" and in my free time enjoy "reading, running, and spending time with my family." My recent writing includes "Free-to-play monetisation has barely changed in ten years" and "The Mom Test in the AI era," alongside projects like Hearthroot Online — "A medieval idle browser MMORPG built for long, satisfying grinds" — Keystorm, Albion Online Grind, Stealth Labs, and the archived Cultivate.
- [Stepan Parunashvili](https://stopa.io/) — Stepan Parunashvili runs his startup Instant — "Build real-time and offline apps" — and links out to Twitter and his favorite books. His essays range from "iPhone dumbphone" and "A Graph-Based Firebase" to "LLisp: Lisp in Lisp," "Bel in Clojure," and "What Gödel Discovered."
- [Glenn Hitchcock](https://glenn.me/) — Glenn Hitchcock is a designer — "Brand, product and process. Mostly tools for the people who design and build software." He was Creative Director at Poolside [2024–2026] for an AI company building open models that write software, directed the Design Engineering team at Vercel [2022–2024] and was a principal designer throughout (Geist, the dashboard, vercel.com and nextjs.org, the conferences), led product design across macOS and the web at Sketch [2019–2022], and built brands and apps for startups and enterprises at Fueled [2011–2019]. Elsewhere: Devouring Details, animations.dev and index.how soon — "Separate projects, one idea: design taught the way it is actually practised" — plus a turn on Dive Club; @glennui and hi@glenn.me.
- [Amelia Wattenberger](https://wattenberger.com/) — Amelia Wattenberger leads with: "I create things on the web, explore novel interfaces, turn data into meaning, and empower devs with AI." She's currently a Principal Research Engineer exploring novel UIs + playing with ML on a tiny R&D team within GitHub, and she made the Fullstack D3 and Data Visualization book & course. This site is WIP, with a link to the old one.
- [All posts](https://www.seangoedecke.com/) — The page is nothing but a list of recent posts, dated and tagged — "October 11, 2026 │ ethics", "October 10, 2026 │ ai, tech companies", "September 20, 2026 │ shipping, emotional regulation". What recurs across the entries is ai, good engineers, tech companies, shipping, system one, model welfare, and prompting; no bio, contact, or socials appear here.
- [Phil Eaton](https://eatonphil.com/) — Phil (he/him) is a Durham, NC–based "college dropout (not by choice; stay in school!)" who says "for the last 10 years I've chased my way down the software stack starting from humble beginnings with the venerable jQuery and PHP" — he was a software development manager at Oracle, a cofounder who led marketing at TigerBeetle, and a staff developer on distributed Postgres at EnterpriseDB, and today he's bootstrapping The Consensus to provide research, data, and tools for experienced programmers. He runs a Software Internals Book Club (3k+ members), /r/databasedevelopment (10k+ members), and a Software Internals Discord (9k+ members) that "has, among other things, become a home for database and distributed systems developers." His writing passed 1.5 million total views and has been cited in the book Writing for Developers, and he asks you to connect on LinkedIn (12k+ followers), Twitter (30k+ followers), Bluesky (6k+ followers), his mailing list (3k+ subscribers), or phil@eatonphil.com.
- [Florian - Design Engineer](https://floriankiem.com/) — Florian is a design engineer, and the page is essentially the work: "Design engineering for Rogo, an AI platform for financial research — the marketing website and careers page," alongside Flow, Prodex, Sona, and Superpower. Across them that means design and engineering — Flow Engineering's web presence down to "an animated 404," Prodex's site introducing "Dexter, an AI industrial engineer for factories," Sona's transcripts, summaries, and key insights, and Superpower's health data categories, protocols, and mobile app surfaces.
- [Experiments. Learnings. Opinions. – Julian Paul - Julian Paul](https://julianpaul.me/) — "Servus. I'm Julian, a Bermudian-born Austrian" who works with SaaS startups to design intuitive UI/UX and lead product delivery — "turning rough ideas into working software with fast-moving teams" — and is currently Head of Product @Valley while sporadically helping founders name their dream business via @nominal.name. His "portfolio of bets" covers shipped products like early.tools, feed-letter.com and tasteful.haus, alongside a "Failed" shelf and a "Future" one with vibi.ng, "where he vibes to House music, which I love to curate & DJ." Reach him at contact@julianpaul.me or via LinkedIn, Instagram, GitHub, 𝕏 and his CV.
- [Stas Poliakov](https://plkv.works/) — Stas Poliakov's edge is "systems that don't kill the magic": he takes half-shipped products, brand debt, or messy user flows and turns them into clean systems your team can build on without him in the room. For 18 years he's designed for companies backed by Morgan Stanley, Valor, Sam Altman, a16z, and Index Ventures — launching verticals and rebuilding the enterprise design system at Republic, untangling dashboards at Coinwatch, taking GetGen AI from zero to first release, defining product for Sizl's $3.5M raise, and earlier building Yandex's first in-house design studio, Tochka's rebrand, VDNH wayfinding, and PIK's brand foundation. He also runs Magic × Logic and builds his own tools — Typedump, TypeTray, and Anclave — digs across genres for deeply curated playlists, and his email is copied to clipboard.
- [Paul Stamatiou](https://paulstamatiou.com/) — "Welcome to my corner of the web" — Paul Stamatiou has been "building and running this site for over 20 years, writing about design, code, and just about anything that interests me." He's the Head of Design at Sesame, "where I work on voice-first personal intelligence," a co-founder of Limitless (acquired by Meta), a two-time Y Combinator alum, and spent nine years on Twitter's design team pre-IPO — with posts, gear, and photosets filling out the rest.
- [Joshua Guo | V2SPACE](https://v2space.net/) — Joshua Guo builds AI tools, design systems, and visual experiences for the web, working "between design and code, staying close to the product until an idea becomes something people can use." He "rarely stop[s] at the mockup," so his partnerships offer four weeks of hands-on use of your product and ten posts for $1,795, and his Shader for Interfaces agent skill — "guidance on performance, accessibility, and browser verification" — lives on GitHub.
- [Hey, I'm Elissa](https://elissamartial.com/) — Elissa's Portfolio opens with an image and the line “Why not aspire to make thP worDd (juxt P litqke) magical?” — plus “hey, i'm starting a mail club.” No other work, socials, or contact details appear on the page.
- [Alexey Guzey](https://guzey.com/) — "I want to help build a just, beautiful future," writes Alexey Guzey, who is "most inspired by Chardin, Tolstoy, Montaigne, and Cowen," and who invites you to email him at alexey@guzey.com, follow his Twitter @alexeyguzey, or write advice@guzey.com for advice and alexey@newscience.org for New Science questions. His most notable work includes "Matthew Walker's 'Why We Sleep' Is Riddled with Scientific and Factual Errors," "How Life Sciences Actually Work," and "Why You Should Start a Blog Right Now," with recent posts like "Why I believe in AGI (again)" and "I ran out of money a year ago, spent the last of my savings on a prostitute in Hong Kong, and became a commie."
- [Ryan Mulligan](https://ryanmulligan.dev/) — This is a website made by me, Ryan Mulligan, "a front-end builder of the web and fellow passenger through space and time" — a front-end engineer and creative developer with over a decade of experience building for the web, whose priorities are "influenced by empathy" and who believes in the rule of least power. The page collects dozens of my CodePen demos — CSS Skateboard, <pixel-canvas>, Metrognome, CSS Putt-Putt Radio Buttons — alongside articles like "Transition to the Other Side with Container Query Units" and "Some Things About Keyframes". "When I'm not busy building for a better web, you can catch me noodling on my acoustic guitar," and "Want to know more? Say hello anytime!" via email.
- [Learn from Real Projects | Newsletter](https://www.sandromaglione.com/newsletter) — I am making a complete game with AI, without writing any code or creating any assets manually. And it's not your usual slop game — this guide will show you the entire process, and everything that I learned. **Lands in 2–3 weeks**, expected 28 Oct – 4 Nov 2026.
- [Matt Rothenberg is a Designer and Front-End Developer based in New ...](https://mattrothenberg.com/) — Matt Rothenberg is a designer and front-end developer who says "I'm very employable" — he works at Cloudflare, where he "maintain[s] our design system and manage[s] our design engineering team," and before that was at GitHub Next, where he "explored the future of software development" and "shipped some big hits like Copilot," along with stints at Clearbit and Heroku and helping the UNDP build their Digital Development Compass. He also freelances and advises, and writes about "web development, design systems, and the tools that make building for the web better," adding "I'd love to come on your podcast, speak at your conference, or write for your publication."
- [nickbytes](https://www.nickbytes.com/) — Nick Beattie's whole homepage is a bio line — "Engineering @ Coinbase. Formerly The Clearing Company (acq. by Coinbase), Polymarket, Rainbow, Truework." — plus twitter, github, linkedin, resume and email links. His writing so far is the [2023 Reading List](https://www.nickbytes.com/posts/2023-Reading-List), "a running list of inspiring products and companies..." pulled from are.na, alongside a "reading now" list of links fetched from are.na.
- [Adam Majmudar](https://adammaj.com/) — I'm currently doing research + special projects at OpenAI; before this I did a year of deep dives in residence at Bain Capital Ventures, three years as a founding engineer at thirdweb, and two years studying computer science and neuroscience at the University of Pennsylvania [now on leave]. I love creating [writing, software, startups] — 'Startups are special because they let you create beautiful things for the world at scale.' I'm interested in neuroscience and neurotech, education [especially ages 0-14], health and fitness, learning, and beautiful art; Checkout my reading, writing, drawings, and deep dives.
- [Daily Developer Tips](https://gomakethings.com/articles/) — A personal site where the author says, "I write about the intersection of frontend web development, punk, and gardening. I used to write more. Now I write less." The archive runs from May 2026 through October 2026, mixing CSS and JavaScript how-tos ("How to add icons to external links with CSS") with essays like "AI is fucking awful (the guide)," "Abolish patents," and "Crying to punk." The only subscription offered is RSS.
- [Emil Kowalski](https://emilkowal.ski/) — Emil Kowalski says, "Today I work on the Web team at Linear," and previously worked on the design team at Vercel, where he likes to build things for designers and developers and think deeply about the user interface, how it looks, feels, behaves. He writes about UI and animation, including "Building a Toast Component" about building Sonner, "Developing Taste," and "7 Practical Animation Tips," and offers an "Exclusive, newsletter-only content once a month. No spam, no nonsense."
- [jzhao.xyz](https://jzhao.xyz/) — I'm Jacky, and this is my "little hypertext garden on the Internet" — make yourself at home! Currently exploring what "agentic and communal" technology looks like at Replit, he asks "how might we create infrastructures and technologies that empower the residents of the web to have access to the same tools as the architects?", caring deeply about creating spaces that enable others to have more agency, and inviting you toward the oak letter desk, the hand-crafted workbench, and the bookshelf on the far wall.

## Tools

- [Context.dev: Web Data API for AI Agents (Scrape, Search, Crawl)](https://www.context.dev/) — Context.dev gives your agent access to the web in one API: search, scraping, people data, and company data — scrape any page or PDF into Markdown, HTML, structured fields, images, or screenshots in one request, ask a research question and get a structured answer in your JSON shape, and monitor pages on a schedule. "You send a URL and get the page, not a list of settings to tune" — rendering, proxies, and retries run on every request, with a 99.96% scrape success rate and no configuration. Start building with 1,000 free credits every month, no credit card required.
- [Enjoy Agentic — A superagent for your computer.](https://enjoy.dev/) — JOY is 'a superagent for your computer' that brings 'the best AI from every company, in one place'—Claude Code, Codex, Grok Build, Antigravity, Muse Code and OpenCode—each using 'the subscription you already have.' It builds apps, automations, presentations and personal tools, tracks your subscription limits, can 'run local coding agents on your own computer' overnight where 'it costs nothing,' and with Enjoy Cloud lets you manage projects from any browser or your phone.
- [celld: Durable Objects, self-hosted](https://celld.dev/) — celld is Durable Objects, self-hosted: Workers handle requests, while Durable Objects, KV, Queues, D1, and Workflows keep their state in cells, each with its own SQLite database, and nodes share a bucket for durable storage. It keeps the Durable Objects programming model and gives you control over where cells run, how their state is stored, and how you investigate failures—"a primitive this good deserves to run anywhere." Self-hosting puts you in charge of your nodes, bucket provider, and operations, but it doesn't guarantee reliability.
- [Subframe — design & build in one tool](https://www.subframe.com/) — Subframe is design & build in one tool for macOS: drag & drop, layers, inspector, with a canvas based on HTML & React so you can “implement it exactly as designed.” It’s “a browser, for building” where you can work with Claude Code and Codex directly, and start free with one project and limited AI credits or go Pro at $20/editor/month for unlimited projects and 6x AI credits.
- [dither-kit — dithered charts & components for shadcn/ui](https://www.tripwire.sh/dither-kit) — dither-kit is dithered charts & components for shadcn/ui: install via @dither-kit/cli — "lockfile for update / diff, pulls core + deps automatically" — or paste into Claude Code, Cursor, or any agent to install + wire up a chart. Register it once in components.json, then add by @name with shadcn, and files land in components/dither-kit/. Charts (area, bar, line, pie, radar) tweak from the floating dial panel with knobs like variant, bloom, stackType, colors, animate, and interactive, while button and gradient stand standalone — "none of these pull in the chart engine."
- [Tripwire — The firewall for your OSS projects](https://www.tripwire.sh/) — Tripwire is "the firewall for your OSS projects": install the GitHub App and it starts ingesting contributor activity — "change requests, comments, and the rest" — running every event through workflows of triggers, rules, and actions so maintainers can "Block noise. Pass signal." Org members "skip rule evaluation entirely"; contributors get "one sentence" while maintainers see the public run page with the evidence behind each finding. It isn't shipping yet — the page only offers a waitlist, beta invites, and "Request access," with no pricing shown.
- [Koboyo · Infinite Canvas](https://koboyo.com/) — Koboyo is an infinite canvas where you "Double-click anywhere to add text or pick a tool" — R for rectangle, O for ellipse, A for arrow. It also does "Slides & Diagrams as Code," with zoom & reset view and keyboard shortcuts. Nothing about pricing or who it's for appears on the page.
- [boat: Cheapest, Most Powerful Sandboxes for Agents](https://boat.dev/) — "boat is the cheapest, most powerful sandbox for agents, built for agent factories" — each one a persistent Ubuntu VM with SSH and SCP access, Docker support inside the VM, a dedicated IPv6 or IPv4 per machine, a 60fps virtual desktop, and fast disk-level forking from a snapshot, built for AI agents, for programmatic use, and for humans. Pricing is "simple, honest": pay only for the sandboxes you run, billed by the second, with a $20 minimum per month, after a 7-day free trial (25 compute hours).
- [AI coding agents from Discord — Kimaki](https://kimaki.dev/) — Kimaki turns Discord into the control surface for your coding agents — "Each channel is a project, each thread is a session. Message your agents from anywhere and come back to finished work." It's a collaborative agent orchestrator that drives every feature of OpenCode from Discord, installable with `npx -y kimaki@latest` and open on GitHub. No pricing appears on the page.
- [MotherDuck | The Cloud Data Warehouse Built on DuckDB](https://motherduck.com/) — MotherDuck is "the cloud data warehouse built on DuckDB" — "fast, serverless analytics powered by DuckDB — with dedicated compute for every user and every agent." Built for builders and the agents they run, it promises that "every person, dashboard, and agent session gets its own isolated DuckDB instance — a Duckling — spun up in milliseconds," with cold starts under 100ms and no noisy neighbors. Alongside that agent-first architecture come Guides ("the context layer for agents"), Flights for Python pipelines, Dives for agent-built visualizations, and MCP, CLI and REST interfaces plus integrations from dbt and Airflow to Hex, Tableau and Fivetran.
- [lisse](https://corne.rs/) — Lisse is "a small JavaScript library that draws squircle corners, the same continuous curve Figma and iOS use." It ships bindings for React, Vue, and Svelte plus a framework-agnostic core, with per-corner control, borders, and shadows included.
- [Scritto](https://scrit.to/) — Scritto is a JavaScript library that animates text in place: give an element a new value and only the characters that changed move—each one rolls from the old character to the new one while the rest hold their position. It works on numbers, words, and emoji, with bindings for React, Vue, Svelte, and Solid, and a core that runs without a framework.
- [Highlighters](https://highlighte.rs/) — A library that lets you "draw marker strokes over web text" — "not a coloured box sitting behind the words, an actual stroke off a nib: ink that pools where a line starts and stops, streaks left behind as it dries, a little bleed past the last letter." There are three nibs, "the kind you'd find in a desk drawer" — a broad chisel, a rounded bullet, a fine point — and it never touches your text: the marks are painted on top, so words stay selectable and searchable and a mark holds its place through scrolling and a resize, darkening where passes overlap. It's small and runs anywhere, with bindings for React, Vue and Svelte (npm install @highlighters/core, /react, /vue, /svelte).
- [Jan - Open-Source ChatGPT Replacement - Jan](https://www.jan.ai/) — Meet Jan: “Your personal intelligence. Run any model, your way.” It’s a free & open-source ChatGPT replacement with 7M+ downloads, built in public on GitHub and Hugging Face for the people who build and use it.
- [Knap · Turn data into Markdown](https://knap.md/) — Knap turns data into Markdown: "Add variables inline with Markdown. Filters modify values and formatting" — including blockquotes, tables, and YAML frontmatter. "Generate Markdown from Knap templates" via the CLI (`npx knap render template.md --data data.json --output note.md`), or add templating to your app with the API (`npm install knap`). The page also points to Obsidian Web Clipper and Obsidian Importer for getting pages and other file formats into Markdown.
- [effect-mq](https://www.effect-mq.com/) — Effect-mq is background jobs for Effect: "Effect-native" — jobs are schemas, handlers are Effects, workers are Layers, so interruption, retries, and timeouts run on the Effect runtime instead of bolted-on process machinery. Storage is a seam — Postgres through your drizzle schema, Redis through atomic Lua scripts, memory for tests — and producers are split from runners so "Enqueueing never requires a Worker, and the type system enforces it." It also ships operable: a run ledger, metadata queries, repeatable schedules with exactly-once ticks, dedup modes, cancellation of running jobs, tracing and metrics.
- [AtAt for Mac — Your AI agent, wherever you type](https://atatapp.com/) — “Everything you see is a prompt.” AtAt is for Mac users who want AI to come to them: “You don't go to AtAt. It comes to you”—take a screenshot, select text, pick a copy, type @@ in any text field, or press ⌥⇥, and “the AI you already use answers,” with Claude Code, Codex, Cursor, your own API key, or a local model. Start with a 7-day free trial; after that, pick monthly, yearly or pay once—$4.92 a month, down from $9, billed $59 a year, or $119 once, down from $169—and without a plan screenshots, OCR, clipboard history and both editors keep working, plus dictation stays free for 2,000 words a week when you sign in.
- [Cactus - On-device AI for Smartphones, Laptops & Edge](https://www.cactuscompute.com/) — Cactus builds Automation Foundation Models for "Mobile, Wearables, AR glasses, Smart homes, Robotics, Automotive, Laptops, Game consoles, TVs, Microcontrollers" — "On-device intelligence on any hardware," with "Sub-30MB binaries for device use, transcription, and more." Latest releases are Whistle, a "16.9 MB open speech recognition model that supports seven languages and runs on CPU only," and Needle 3, "a single 8–29 MB binary that beats models 10× its size on mobile tool calls." The page also covers sub-2-bit quantization, microprocessor-tier CPU-only offline + hybrid models, hybrid routing that "know when they're wrong and request help from the cloud," and a Pebble partnership.
- [Trusted AI analytics | Equals](https://equals.com/) — Equals is trusted AI analytics that syncs your team's tools to a managed warehouse — "No data stack or team required" — with a spreadsheet "calculation layer that's easy to audit, trust, and collaborate on," AI dashboards and models, and agents that "connect over MCP to analyze the metrics your team trusts—not numbers it invented." It's for serious GTM teams — RevOps analysts, finance, CROs, founders — who want "A single source of truth for the entire team. Same question? Same answer," built once and iterated for years, then wired into how the company operates as "A system, not an artifact."
- [hilos · team chat where people and AI agents share the room](https://hilos.sh/) — hilos is "a team chat where agents are members" — ask for a change in a channel and "agents ship real PRs. Other agents review. People approve." It's free, and agents run on your machine, on your own account.
- [AI CMO | Okara](https://okara.ai/) — Okara is "the AI CMO... The only AI CMO you need for growth and marketing" — "10+ Marketing Agents Running 24/7" that research first, generating strategy documents every agent reads before it writes a word, then execute channel by channel across SEO, Reddit, X, LinkedIn, GEO, coding and UGC video, publishing straight into your stack. "Free to start · No credit card required," and it frames the trade as "The $14,000/mo job from $129/mo."
- [Models.dev - An open-source database of AI models](https://models.dev/) — Models.dev presents itself as "An open-source database of AI models" — a browsable table listing each model with its lab, number of providers, context and output limits, whether it supports reasoning, tool calls, structured output and temperature, its weights status (Open or Closed), price, and release and update dates. Pricing is listed per model rather than as a product tier, and the page is a free public reference with no stated paid plan.
- [Product execution for the AI era | Modem](https://modem.ai/) — Modem "discovers and organizes your customer concerns" — support threads, sales calls, community posts, social comments, even your own data via our API — working out "who raised it and what it is about," then grouping what customers say into topics and tracking the issues and pull requests working on each one. Product, engineering, success, and sales "all work from the same record of what customers said and what shipped," with people and agents self-serving answers through Modem's MCP. Unlimited users on every plan: Free at $0/mo with 2,500 events, Startup $80/mo, Scale $250/mo, or "Try Scale free for 14 days."
- [pgbot.dev — Postgres intelligence for AI agents & apps](https://pgbot.dev/) — “Nobody reads database metrics. pgbot does.” Connect any PostgreSQL database and it gives you “answers, not dashboards: what's healthy, what's broken, and what to fix first” — health, query performance, tables and indexes, plus AI-powered explanations you can ask for in plain English. Connect directly over the wire to Supabase, Neon, RDS or public DBs, or run the agent next to a database that never leaves your network. For agents, “pgbot mcp speaks the Model Context Protocol on stdio,” exposing deterministic tools only — inspect and unused_indexes — read-only by construction, with an open-source agent for private deployments.
- [DeltaDB](https://delta.dev/) — Delta is "a multiplayer environment for coding with agents," where "the unit of work is a thread: the conversation with an agent and the checkout of the repository it works in, kept together as one shareable artifact." Underneath sits DeltaDB, "the version control layer underneath Delta" — "where Git captures a snapshot at each commit, DeltaDB records work as a stream of fine-grained deltas," each with a stable identity so "a reference anchors to a change rather than a line number and survives as the code moves." You can "open Delta from the desktop or web, or move to a cloud runner," and invite teammates into the same thread to review, comment, and work alongside the agent in real time.
- [GitHub - brijr/iris: Screenshots of live websites. Minimal interfac...](https://github.com/brijr/iris) — Iris is "a camera for coding agents. One fast command or MCP tool call produces one trustworthy image" — a CLI that renders with your real installed Chrome over the DevTools Protocol, waits for fonts, image loads and entrance animations, and captures full pages, `--selector` elements, dark mode, or batches with `--json` output. The same binary ships a local stdio MCP server exposing one `capture` tool so agents get pixels inline, installable via `curl -fsSL https://raw.githubusercontent.com/brijr/iris/main/install.sh | sh` or `cargo install iris-screenshot`, with the only runtime dependency an installed Chrome-family browser. It's MIT licensed.
- [treg — the tool catalog for your agent](https://treg.to/) — treg is "the tool catalog for your agent" — 3,900+ endpoints from 111 providers behind one unified key, so "your agent asks for the task, not the tool" and "every tool in the catalog answers to it." No subscription: "Semrush, Moz, Crunchbase, Hunter - seats you'd never buy for one agent run" become fractions of a cent per call, price shown before the call, $1.00 free to start, 0% additional fee, bring-your-own-key calls route through unmetered, and it's "100% open source · AGPL."
- [AI Model & API Providers Analysis | Artificial Analysis](https://artificialanalysis.ai/) — Artificial Analysis is "independent analysis of AI" — "Understand the AI landscape to choose the best model and provider for your use case." It runs its own independent evaluations and leaderboards (Intelligence Index, Coding Agent Index, Cyber Index, Openness Index, Image Arena, Video Arena, Speech Arena) plus cost per task, speed and latency, pricing and provider endpoint comparisons, and lets you compare models side-by-side on intelligence, pricing, speed, latency and benchmarks. No pricing, free tier or open-source status for the site itself appears on the page.
- [Hatchet | The orchestration engine for teams who ship](https://hatchet.run/) — Hatchet is “the orchestration engine for teams who ship”: write tasks and workflows as code in TypeScript, Python, or Go, then run workers on your own infrastructure while the orchestration engine is available as a managed service or can be self-hosted. It’s “Open-source & self-hostable. Fully MIT-licensed,” with durable tasks, retries, schedules, event/webhook triggers, priorities, rate limits, and a real-time web UI for monitoring and logging.
- [Glaze by Raycast. Desktop apps, reimagined by you.](https://www.glaze.app/) — Glaze lets you build your own desktop apps just by describing what you want — "Beautiful, powerful, and truly personal" — and they run locally on your Mac, so "no server or internet connection required." It's for anyone who wants internal tools, personal utilities, menu bar apps, or workflow automations, with Glaze's own models or your Claude subscription, annotation, team stores, and a public Glaze Store. Currently macOS Tahoe and Apple Silicon; you own your app, its code and content, and Pro adds unlisted publishing for 1:1 sharing.
- [bg.layers - Visualize and Edit CSS Background Layers](https://bg-layers.vivitseng.com/) — bg.layers breaks down CSS backgrounds, layer by layer — paste any background CSS and see what each layer contributes, separately. It's a playground where you drag to reorder the layers and try an example.
- [Whirrls](https://www.whirrls.com/) — Whirrls is “A growing collection of decorative illustrations for your projects”: a Figma illustration pack of “1000+ hand-drawn elements.” Designers and creators praise it for “web, social media design, or other projects,” with one calling it “like having a creative playground at your fingertips.” It’s sold through a “Get Now” Lemon Squeezy link; no pricing, free tier, or open-source status is shown.
- [Feather](https://feather.computer/) — Feather is a tool whose "Brief" removes what's done, keeps what matters, and nudges what needs you, while "Sorting" gives you "An inbox that sorts, merges, and surfaces insights, on its own." No pricing, free tier, or open-source status is shown on the page.
- [Pullfrog](https://pullfrog.com/) — Pullfrog is a GitHub bot that runs AI agents on your repo, listening for PRs opened, issues created, reviews submitted, and CI failures—or you can “just mention `@pullfrog` to assign tasks.” It’s open source with no per-seat pricing, “Personal accounts and public repositories stay free,” Organization is $30/month, and Enterprise is custom. All agent runs happen in your repo’s GitHub Actions, with Pullfrog Router, your own key, or plans like Claude Pro/Max, ChatGPT Codex, Grok, Kimi Code, and OpenCode Go.
- [BrandBird — Turn Screenshots into Beautiful Social Media Graphics](https://www.brandbird.app/) — BrandBird is "the ultimate screenshot editor for founders, creators, marketters, who value beautiful design" — it turns screenshots into branded social media graphics with backgrounds, 3D effects, and mockups applied "with a single click," so you can "instantly brand your screenshots to make your content recognizable & increase your engagement." Founder Jim built it after finding visual creation tedious even as a professional designer: "My mission is to help SaaS founders create beautiful graphics with minimal effort even if they have zero design skills!"
- [Montage](https://montage.tools/) — As captured, Montage shows no readable content — just leftover drag-and-drop scaffolding: "To pick up a draggable item, press the space bar. While dragging, use the arrow keys to move the item. Press space again to drop the item in its new position, or press escape to cancel." Nothing about what it does, who it's for, or what it costs appears on the page.
- [iii — Three primitives. Zero integration cost.](https://iii.dev/) — iii is a system where you add workers — `iii trigger compose::add worker=http worker=database`, or your own code — and get "Three workers. Different languages. One connected system." From there it promises "Compose, observe, discover, extend, and react. All in the same system": a POST /orders calls orders::create then database::execute ("3 spans · 2 languages · local + cloud · one trace id"), a prompt hunts for capabilities the running system already has, and one `github::pr::event` reaches four subscribers — "One event. Many reactions." The page shows no pricing, free tier, or open-source status.
- [Flows – The better way to build product adoption](https://flows.sh/) — Flows is "product adoption infrastructure that lets modern teams build anything, no-code or all-code" — product tours, workflows, and in-product surveys (NPS, CES, CSAT, PMF) built with "your own components and design system." Pricing is "pay only for onboarded users": Hobby is free for 100 MTUs with no credit card required, Pro is $30/month for 600 MTUs, and the SDKs are "open-source SDKs... Documented, extensible, and built by developers for developers."
- [Library — Design systems & context for humans and agents](https://library.guide/) — Library is "the infrastructure your design system runs on" — it reads your components, tokens, and patterns at the source, keeps them live and browsable at a URL, and lets you ask anything in plain language, "for your team today. For your agents tomorrow." It plugs into Claude, Cursor, v0, and more via MCP, and is free for 30 days, then $15 per editor / month with unlimited viewers — AI answers billed separately, priced per token.
- [Faces: Interactive Presentations](https://faces.app/) — Faces frames the slide's lineage — "Kodak made slides mainstream, Microsoft put them inside our computers and Google took them to the internet" — and declares, "We're making them smart for a future driven by artificial intelligence." The page walks that evolution from Kodachrome Physical Slides through PowerPoint Digital Slides and Google Collaborative Slides to its own end point: Faces Smart Slides. No pricing, free tier, or open-source status appears on the page.
- [Traces](https://traces.com/) — Traces is a tool where "software developers & teams" "share sessions live & compound your learning" — upload traces from 10+ supported agents in the CLI, then "Download a trace, or continue it in Claude Code." It's "Free for individuals & small teams" with unlimited traces, unlimited teams and up to 50 seats, while a Custom tier adds "Self hosting / On-prem, Priority support, Team onboarding & training." Teams get "one place to see work in progress, share context on finished work, and see which agents people are using."
- [Slim - Local HTTPS Domains, Tunnels & Dev Environment Toolkit](https://slim.sh/) — Slim turns `localhost:3000` into `https://app.test` — "Free Forever · Built with Go" — a single binary that handles local HTTPS domains with trusted certificates, path routing, WebSocket and HMR support, plus one-command public URLs on slim.show with password protection and auto-expiry. Install with `curl -sL https://slim.sh/install.sh | sh`, or build from source on GitHub.
- [Detail | Your codebase is full of bugs](https://detail.dev/) — Detail fixes bugs in the background while you ship features: it exercises your code to find thousands of bugs, picks the top 1% you're most likely to care about, and sends you a PR with a fix—or a ticket so you can fix it yourself. It's for fast-moving teams, with SOC 2 Type II and zero data retention, and the first week is free. Get started in under 5 minutes.
- [Forma – your canvas for notes, tasks and anything else](https://www.useforma.app/) — Primitive task lists are over—spatial canvas is where it’s at. Forma is a native macOS app for notes and tasks on a canvas, for solo creators, designers, and developers who plan projects spatially and find folder-based tools limiting. It’s not free—one-time purchase of $9.99, no subscription, no free trial, sold through the Mac App Store.
- [Echo](https://replay.software/echo) — Echo is "the fast & modern SSH + Mosh client for iOS & iPadOS that makes the mobile terminal a pleasure" — connect, execute, and automate from your pocket, with built-in Mosh support so sessions stay alive "even when you switch networks or have patchy cell signal." It's $2.99 on the App Store, built for iPhone & iPad on iOS 26+, and its "minimal, distraction-free UI" is pitched as "the perfect environment to interact with coding agents on the go."
- [Entire · A new developer platform is coming](https://entire.com/?redirected_from=entire.io) — Entire is a new developer platform on the way: Git hosting with "the fastest Git network on Earth," where agents clone and push to your repositories up to 89 times faster than the competition, and every commit an agent makes becomes a checkpoint paired with the conversation behind it. It's "built for agents, and humans" — all features are available through the CLI (open source · MIT licensed), the semantic graph that cuts token spend is 100% local and open source, and multi-region hosting is available today in India, Australia, EU and the US.
- [before-and-after](https://jm.sv/before-and-after) — “Put visual proof in every pull request.” This skill teaches coding agents to show their work with before and after screenshots and video, access protected preview deployments, and format every capture for GitHub. Install it with `npx skills add vercel-labs/before-and-after#main`; browser navigation, authentication, and capture stay with the version-matched skills bundled in `agent-browser`, while before and after formats the media and publishes it through `gh --attach`.
- [Agentation](https://www.agentation.com/) — Agentation is a UI annotation tool: click the icon in the bottom-right corner, hover to highlight elements, click to add an annotation, write your feedback, then copy the formatted markdown and paste it into your agent. Its output includes "CSS selectors to grep your codebase," source file paths, the React component tree, computed styles, and your feedback with intent and priority, so instead of describing "the blue button in the sidebar" and hoping the agent guesses right, you give it `.sidebar > button.primary`. It's free for individuals and companies for internal use, with a commercial license available for redistributing it as part of a product you sell.
- [Pool](https://pool.day/) — Pool is an iOS app that saves anything with a screenshot: it "knows what actually matters...", "magically links and categorises your content…", and lets you "organize in pools and share with friends." The page offers a Download on the App Store link alongside Research and Careers, with no pricing or free tier shown.
- [GitHub - dmmulroy/better-result: Lightweight Result type for TypeSc...](https://github.com/dmmulroy/better-result) — better-result is a "Lightweight Result type for TypeScript with generator-based composition" — "Make failures explicit: TypeScript shows what a function returns when it succeeds and what can go wrong." Install it with `npm install better-result`: it "requires TypeScript 5.4 or newer, is ESM-only, and has zero runtime dependencies," and ships under the MIT license. A portable `adopt-better-result` skill guides compatible coding agents through a repository-wide error-handling audit or one approved vertical migration slice.
- [Daytona - Secure Infrastructure for Running AI-Generated Code](https://www.daytona.io/) — Daytona is "Secure and Elastic Infrastructure for Running Your AI-Generated Code," with sub-90ms sandbox creation, separated and isolated runtime protection, stateful sandboxes, and programmatic control across process, file, Git, and LSP APIs. Built for AI agents, LLMs, and evals, it offers "Instant Sandboxes. Pay-as-You-Go" with "$200 in free compute included" and per-second billing.
- [Conductor - Run a team of coding agents on your Mac](https://www.conductor.build/) — Conductor runs a team of coding agents on your Mac. New cloud workspace: “Building snapshot 0ms ›booting Firecracker microVM ›restoring repository snapshot.”
- [Ebb - macOS Focus App](https://ebb.cool/) — Ebb is a macOS app that takes you "From Distracted to Focused in 4 Steps": set goals with Tides, schedule focus sessions around your peak energy hours, block distracting apps and websites with "one click to enter deep work—no willpower required," and track your progress with "screen time insights on steroids." It's a free download with "No credit card required" ("Only your Soul"), backed by a 30-day money back guarantee and a worldwide community logging "thousands of hours of deep work and counting."
- [Channel3](https://trychannel3.com/) — Channel3 is "building the world's highest quality product graph, so AI agents can reliably search, recommend, and purchase products," with brand partners including Walmart, Best Buy, and CVS. It's for developers building agentic shopping experiences, brands that want products to appear in AI apps and agents, and enterprises embedding shopping into their platforms: "Shopping is moving into AI," and "Channel3 provides the infrastructure to make it happen."
- [Chroma](https://www.trychroma.com/) — Chroma is "fast, serverless, and scalable infrastructure supporting vector, full-text, regex, and metadata search," built on object storage and open-source under Apache 2.0. It's aimed at developers who want "no engineering ops" — auto-scales with usage, no manual tuning, serverless pricing — and you can get started in 30 seconds or less with $5 in free credits, or locally via `pip install chromadb`. Enterprise brings "the security, compliance, education and operational model enterprises need" with BYOC in your VPC, multi-region replication, and 24/7 SLAs.
- [Butter - Local Agent Sandboxes](https://www.butter.dev/) — Butter is building bVisor, "an incredibly lightweight sandbox runtime for AI agents" that embeds directly into your local process and provides a safe bash environment. It's for people running agents locally who don't want the overhead of VMs or remote infra.
- [HumanLayer - Close your editor forever.](https://www.humanlayer.dev/) — HumanLayer is a "multiplayer coding agent IDE and cloud" that brings agent sessions, plan artifacts, and code diffs together in one place for your team to collaborate and ship, shipping "composable pieces to meet software factory builders where they already are" — bring your own compute, development environment, and agent harness, or run the HumanLayer stack on your workstation or remote workers. "Do not outsource the thinking": structured workflows, inline comment-driven design reviews, and design docs that feed straight back to the agents, because "the doc is the interface to the code, not a separate artifact you hope someone reads before shipping."
- [Factory | Agent-Native Software Development](https://factory.com/) — Factory is agent-native software development, built on three pillars: "Sovereign, Model-Independent Intelligence" — control where your system runs, how it learns, and which models it uses — plus "Trusted, Governed Self-Improvement," a governed system that continuously turns enterprise signals into validated production software. The third, "Measurable Business Value," connects engineering adoption and effectiveness to growth, profitability, risk, and business performance. No pricing, free tier, or open-source status is shown on the page.
- [Kernel: Browser infrastructure for web agents and automations](https://www.kernel.sh/) — Kernel is browser infrastructure for web agents and automations — sessions with a CDP websocket URL, headful mode, and stealth enabled, plus captcha clearing, profiles signed in to Google and YouTube, checkout forms filled from an authorized vault, and regional browsing. Per-action speed inside a running session, measured by computesdk, is the pitch: browser use 3.61 actions/sec, browserbase 4.00 actions/sec, kernel 6.43 actions/sec — "We evaluated many options, and Kernel is the only one that could deliver the performance all of our customers' test suites required." It's "loved by 11,000+ teams building agents," including the prompting company running 50,000+ kernel browsers every month to get brands cited by llms.
- [Mediabunny](https://mediabunny.dev/) — What it does: "A JavaScript library for reading, writing, and converting video and audio files. Directly in the browser, and faster than anybunny else." Mediabunny reads and writes any media file from memory, disk, or the network, generates MP4/WebM files programmatically, and does "hopping-fast file conversion" through transmuxing, transcoding, resizing, rotation, audio resampling and trimming, all built "100% implemented in TypeScript" with zero dependencies and hardware-accelerated via WebCodecs. It is "an open-source project released under the MPL-2.0" and "therefore free to use for any purpose, including closed-source commercial use," supported by sponsors rather than paid tiers.
- [Welcome to Cosmos](https://www.cosmos.so/) — Cosmos is a place to "build your world, your way": search by color, create collections for every project, outfit, or space, find similar elements, show/blur/hide images flagged as AI-generated, and invite others to build collections with you. "Join Cosmos for free," save inspiration as you browse the web, shop from brands like LOEWE and Bottega Veneta — it's "used by the world's leading creative teams, studios, and students."
- [unavatar](https://unavatar.io/) — unavatar is "the universal avatars API: one HTTP endpoint for user profile photos from 75+ sources like GitHub, X, Instagram, and Gravatar" — and the same URL pattern also resolves logos, favicons, app icons, and artwork. "No SDK, no tokens for the free tier, no setup": just an `<img>` tag or a GET request, with 25 requests/day free per IP (50/day with an API key) and paid usage metered at $0.010 per token — "Pure pay-as-you-go. No minimums, no commitments" — where cached requests are served free and don't count toward your usage. It's "free, open source, and community-driven," crafted by Microlink.io, serving millions of requests per month with 99.6%+ uptime.
- [Boring Avatars: Open-Source React Library & Customizable SVG Avatar...](https://boringavatars.com/) — Boring Avatars is an open-source React library for customizable SVG avatars — you just drop one in: `<Avatar colors={["#00686c","#32c2b9","#edecb3","#fad928","#ff9915"]} variant="beam" />`. The page itself is the demo: profile cards, follower counts, and chat activity, all wearing generated avatars.
- [Microlink Geolocation](https://geolocation.microlink.io/) — Microlink Geolocation is "IP-based location data, simplified" — "Get detailed information about the incoming request based on the IP address." It's "Simple — just one HTTP request" and "Free — no API key needed," returning a JSON payload with ip, city, country (flag, phones, currencies), continent, capitals, languages, tlds, airport, coordinates and timezone, and you can view it on GitHub.
- [Turns websites into data — Microlink](https://microlink.io/) — Microlink is "APIs and tooling to turn any URL into structured output" — one REST endpoint for every product, from Screenshot, Link Preview, Metadata, Markdown ("Built for agents handling website content") and Embed to Search, PDF, Logo, HTML, Function, Text, Media, File Conversion and Insights. There's also an Editor to "write Microlink code and run it in the browser," alongside browser tools like Website Screenshot, Sharing Debugger, Sitemap URLs, URL to Markdown and bulk captures or PDFs.
- [Context7 - Up-to-date documentation for LLMs and AI code editors](https://context7.com/) — "Up-to-date documentation for LLMs and AI code editors" — Context7 lets you explore 146,000+ libraries, each listed with its source, benchmark score, snippet count, update time and trust, from Next.js and React to Docker, Supabase and Cloudflare. Its latest blog post makes the case plainly: "Context7 vs. web search — 34% cheaper, 37% fewer tokens."
- [svgl](https://svgl.app/) — svgl is a collection of 670 logos, where "Each SVG includes a link to its respective product." They're filed under categories like AI, Software, Design, Devtool and Crypto. "Permission must be obtained before using a logo," and removal requests go through a GitHub issue.
- [Fern: SDKs and Docs for your API](https://buildwithfern.com/) — Fern generates Docs, SDKs, and an agent-first CLI for your API from one source of truth, supporting REST, WebSockets, and GraphQL, so you can "Generate beautiful Docs, idiomatic SDKs, and an agent-first CLI from your API spec." It's built for the AI era with docs as code, AI chat, llms.txt, an MCP server, and AI-assisted authoring, and it ships "Enterprise-ready by default" with security, self-hosting, localization, compliance, and SLAs for its 8,000+ customers across Docs, SDKs, and CLI.
- [pqoqubbw/icons](https://lucide-animated.com/) — lucide-animated is a "beautifully crafted" open-source (MIT License) collection of smooth animated icons for your projects — "feel free to use them, share your feedback, and let's make this library awesome together." Crafted with Motion & Lucide and installable with `pnpm dlx shadcn add @lucide-animated/`, it's by Dmytro Tovstokor, who points to Invisible Details: "timing, states, feedback, the weight of a click - every detail, written down."
- [GitButler](https://gitbutler.com/) — GitButler layers onto your existing Git repositories and remotes — "Zero configuration required" — and gives you "Everything You Wished Git Had": stacked branches, parallel branches, unlimited undo, a powerful smartlog, and simple history editing. Built for the AI era, it claims "Agents are 60% faster using GitButler than vanilla Git, with 80% fewer tool calls," via structured output, idempotent commands, and conflict resolution that works with AI-generated code. Free and Open Source.
- [DiceBear | Open Source Avatar Library](https://www.dicebear.com/) — DiceBear is an open source avatar library built on the promise that it's "Same Seed, Same Avatar. Every Time." — use any string as a seed, such as usernames, emails, or IDs, and it generates the identical avatar consistently across all platforms, via HTTP API or packages for JavaScript, PHP, Python, Rust, Go, Dart, .NET, and the CLI. No developer? No problem: the DiceBear Editor is an "Avatar Maker Without Code" where anyone can pick, click, and download a PNG, and a Figma plugin lets designers export a custom style as a ready-to-use package. It's "Free and Open Source. Forever." — the core library is MIT licensed.
- [Smithery - Model Context Protocol Registry](https://www.smithery.ai/) — Smithery is the Model Context Protocol registry where you "Connect agents to thousands of tools and services" — OAuth flows, credential injection, and retries handled automatically, courtesy of agent.pw, "our open-source agent vault." You can browse 26,056+ MCPs (Context7, Exa Search, DevMatch with its "Free tier with 50 monthly credits, $129/mo Pro" among them) and "Publish once, install anywhere—with built-in auth and observability."
- [Sublime — A second brain with a soul](https://sublime.app/) — Sublime is a “second brain with a soul” that gives your ideas one place to grow: capture from anywhere—web, browser extension, or iOS—import from Kindle, X, Instagram, and Readwise, then save one idea and discover 100 more or search by context, feeling, or half-remembered details. It’s for “creative human being[s]” and “builders, thinkers — writers, designers,” and it’s “free until you can’t live without it.”
- [Pika – Create Screenshots and Mockups](https://pika.style/) — Pika is an online screenshot beautifier and mockup generator: "Brand your screenshots, amplify your message, engage your audience" — capture from a URL or the Chrome extension, add frames, backgrounds and annotations, then export in perfect size for social media, docs, landing pages and app stores. It's free without an account (exports carry a small "designed in Pika.style" watermark), while Pika Pro is $15 a month or $150 a year, Team is $12 per seat a month from 2 seats, and there's a one-time Lifetime plan for $299.
- [Tolan: Alien Best Friend](https://www.tolans.com/) — We're building friendly guides that support people in their everyday lives — Tolans are AI characters with 250,000+ active users, over 8 million hours spent with them, and a 4.8-star App Store rating from over 180,000 reviews. "We're building on top of the leading AI models, but the real work is in what we add on top," the team says, and they're an experienced group backed by $30M+ in capital, hiring in-person in San Francisco.
- [Unkey](https://www.unkey.com/) — Unkey is "a single control plane for access and traffic" that lets you "stop assembling your API stack piece by piece" — API keys managed end to end, edge rate limits per IP, user, or key, global gateways, and instant access revocation. It's built for production and scales with you: multi-region routing, automatic scaling, "every request logged, every decision visible." You can "start for free, integrate in minutes, and scale when you need to," with billing that stays predictable as you grow.
- [OpenTelemetry Native Observability · Dash0](https://www.dash0.com/) — Dash0 is an OpenTelemetry-native observability platform: "We watch the agents writing your code, see everything happening in production, and fix problems automatically, often before anyone notices." Built for developers, SREs, and platform engineers on SignalStore — every signal stored once, in your cloud, queried with PromQL, SQL, CLI, and MCP — with transparent pricing based on how many logs, spans, and metric data points you send and store, not users or GB. You can start for free or book a demo.
- [Midlife Engineering – Sound therapy for a harmonious mind](https://www.midlife.engineering/) — Midlife Engineering is "a space where calm meets ambient clarity, inviting you to pause, breathe, and explore sound with harmony, and a slower rhythm" — made for focus, rest, and everything in between, with autoplay beats, tracks, and record session. It leans on the studies it cites, from a 2020 Psych Central report on music lowering heart rate and cortisol to a 2015 Sleep Medicine Reviews meta-analysis on ambient music and sleep quality, with the caveat that honing your ambient ear "won't replace your therapist, but it can make your midlife crisis feel like a pleasing montage instead of a chaotic meltdown." The page shows a Product Hunt featured badge and no pricing.
- [PamPam: The new AI map.](https://www.pampam.city/) — PamPam's AI map maker creates interactive maps from your data — start from scratch, use AI to add places, or bring your own data with a CSV or Google Sheet, no coding needed. You can make a map for free with up to 30 spots, while larger projects and advanced features like map animations, custom themes, and website embeds start at $8 per month.
- [SST](https://sst.dev/) — SST deploys your app's infrastructure from a single TypeScript config — a PlanetScale database, an email sender, a service, and a Next.js site, all wired together with `link` and a custom domain. In its own words: "Deploy everything your app needs with a single config."
- [Cap — Beautiful screen recordings, owned by you.](https://cap.so/) — Cap is "Beautiful screen recordings, owned by you" — one app with three modes: "Record and share with Instant, edit your videos with Studio, or capture and customize images with Screenshot." It's "Truly open source" ("Every line is on GitHub. Audit it, fork it, or contribute the feature you need."), with native apps on macOS, Windows and Linux plus a Chrome extension, and a CLI and local MCP server so Claude Code, Cursor, Codex or "any shell capable agent can record your screen, upload the result, and read back the transcript and summary." "Cap is 100% free for personal use," while a Desktop License costs $58 one time ("Or $29 a year if you would rather pay as you go") for commercial usage rights and Cap Pro runs $12 per user, per month (annual $8.16) for unlimited cloud storage, Cap AI, custom domains, team workspaces and a Loom video importer.
- [Val Town](https://www.val.town/) — Val Town is how developers and operators instantly ship websites, automations, and other tools to live URLs, writing each one as a "val" and deploying it to the web in 100ms. You can sign up, connect your AI agent, and see setup guides for other agents, trusted by "(vibe) coders at companies we admire." No pricing or free tier is shown on the page.
- [Cosmos Keyboards](https://ryanis.cool/cosmos/) — Cosmos is "the easiest way to design a keyboard around your one-of-a-kind hands": scan your hand with just your phone camera, then fit the board to the scan and add a trackball, trackpad, encoder, or OLED display, with support for MX, Choc, NIZ, and Alps switches and 15 different microcontrollers. Order the finished keyboard through partner builders, or build it yourself from exported STLs and STEP models — and if you don't like how it looks, "ask your closest CAD guru to make adjustments." It's "made in the open," with 95% of the code open-source; the other 5% is Pro features that "add extra cosmetic options to your keyboard and help keep this project sustainable."
- [Knock | Notifications infrastructure for developers](https://knock.app/) — Knock is 'notifications infrastructure for developers': one platform to manage all your messaging - product, marketing, and transactional - with 'flexible, AI-native tooling to build any messaging experience you want.' It is built for developers and agents, so you can build, manage, and ship customer engagement from Cursor, Claude, or Codex with environments, version control, and the Knock CLI, and it delivers hundreds of millions of messages per month with 99.99% uptime.
- [poolside](https://poolside.ai/) — "We're building open-weight foundation models and the systems that refine and improve them" — Laguna s 2.1 for "frontier-class reasoning at mid-size cost" (118B params, 8B active, 1M context), and Laguna xs 2.1, "our lightest and fastest agentic coding model," small enough to run on-device. We work in the open, with the Model Factory series on how we train, evaluate, and iterate on foundation models.
- [Dispatched | Background Jobs for Serverless Applications](https://dispatched.dev/) — Dispatched is "The Missing Background Queue for Your Serverless Apps" — "Deploy reliable background jobs in minutes. No infrastructure management required." It's "Indie-hacker Friendly • No Credit Card Required" and "Perfect for Vercel Apps and all serverless environments": you send a simple POST request to queue a job and get a webhook callback, with smart retries, built-in monitoring, and jobs "delayed up to 1 year." No pricing tiers, plans, or open-source status are shown on the page.
- [MiniTAP – Web Sequencer](https://minitap.io/) — MiniTAP is “a fun sequencer for the web” that runs as a browser extension, built because its author “needed a fun and easy way to control 3D graphics in real time.” You can install it from the Chrome Web Store, and “It's Open Source!” with a link to GitHub.

## Learning

- [Intro - The Growth Guide by Demand Curve](https://www.demandcurve.com/growth/intro) — Demand Curve's Growth Guide opens by calling growth "the intersection of all three" — helping attract more of the right eyeballs, helping sales close more of the right clients, helping product serve their needs better — because "Every founder needs to understand growth." It follows with eight numbered stops: Competitive Analysis, Landing pages, Making Ads, Onboarding, Running Ads, Content Marketing, A/B Tests, and What's Next? On the credibility front, it notes "Our average team member has over a decade of growth and marketing experience. And we have 7 current or previous founders on the team."
- [Knowspace](https://knowspace.si/) — Bite-sized facts, fresh every day. A product by Gr8r Studio.
- [Intel: How the world's most advanced chips are made — Flashcards](https://flashcards.dwarkesh.com/intel/) — A learning that walks the fab from end to end — "Explain the basic mechanism of transmission electron microscopy", "Why does a positive charge at the gate open up the channel underneath the insulator?", "Why is ruthenium preferred over copper for interconnects, despite having more bulk resistivity?" — laid out in nine timestamped sections: Bringing up a new node, Lessons from 10 nanometer, From planar to gate-all-around, High-NA EUV and the PDK, A different tech tree, Ruthenium interconnects, Stacking transistors, Hybrid bonding, and a catch-all of diode/BJT/MOSFET questions filed under "Not covered in the video." Price nuggets sit inside answers, not in a pitch: multiple patterning eats time on a "~$200 million EUV machine", and a full EUV mask set runs "$10-15 million" at ~50% mask yield. intel, euv, lithography, transistors, hybrid-bonding, ruthenium
- [Putting the "You" in CPU](https://cpu.land/) — This intro says it’s “the article that I wished I had,” answering “what exactly happens when you run a program on your computer?” from startup to program execution after “almost 40 pages of notes.” It points you to Chapter 1: The “Basics” and, if you’re in a hurry, Chapter 3.
- [Demystifying evals for AI agents](https://www.anthropic.com/research/demystifying-evals-for-ai-agents) — Anthropic's "Demystifying evals for AI agents" teaches that an eval is "a test for an AI system: give an AI an input, then apply grading logic to its output to measure success," then lays out the pieces — task, trial, grader, transcript, outcome, harness — the three grader types (code-based, model-based, human), capability vs. regression evals, agent-type playbooks for coding, conversational, research, and computer use agents, pass@k vs. pass^k, and an eight-step "zero to one" roadmap starting with "20-50 simple tasks drawn from real failures." It closes by comparing automated evals against production monitoring, A/B testing, user feedback, manual transcript review, and systematic human studies — "no single evaluation layer catches every issue" — and an appendix of frameworks (Harbor, Braintrust, LangSmith, Langfuse, Arize). No FAQ or pricing appears on the page.
- [Acknowledgements - How Query Engines Work](https://howqueryengineswork.com/) — This is just the acknowledgements page of *How Query Engines Work* — no table of contents, FAQ, or price, so it's thin: "Special thanks go to Matthew Powers, a.k.a. Mr. Powers, for inspiring me to write this book in the first place," plus thanks to family and the Apache Arrow and DataFusion PMC members, committers, and contributors. About the only practical nugget is that the book is "also available for purchase in ePub, MOBI, and PDF format from https://leanpub.com/how-query-engines-work."
- [HTTP.DEV](https://http.dev/) — http.dev walks through how ==HTTP== "is the foundation of data exchange on the web": the request-response model (method, URL, headers out; status code, headers, body back), the version history from the early-1990s single-line spec through HTTP/1.0, 1.1, HTTP/2's binary framing and multiplexing, and HTTP/3's UDP-based QUIC, then the three core building blocks — headers, methods, status codes — and security via HTTPS, HSTS, CORS, CSP, session cookies, and challenge-response authentication. It closes on a long "See also" list of linked topics, with a note that "This page was delivered over HTTP."
- [Wondering - Learn What You Thought You Couldn't](https://wondering.app/) — Wondering turns anything you want to learn, from LLMs to quantum mechanics to product design, into a personalized course of three-minute lessons with visuals, podcasts, and interactive exercises — "A better habit than doomscrolling." It's built for curious people: bite-sized lessons you can watch, listen to, or read; one global review scheduled with the FSRS spaced repetition algorithm; daily streaks, friend streaks, XP, and streak freezes; personalization by goals and background; and an AI tutor to discuss anything, all in an iPhone app.
- [Learn Inference: inference engineering, explained interactively](https://learn-inference.com/) — LearnInference is "an interactive companion to *Inference Engineering* by Philip Kiely" that "follows the book’s structure and covers the same ground," rewording the explanations and building simulators "for the parts you grasp faster by turning a dial than by reading a paragraph." The page itself is thin: beyond that framing it offers one demo from chapter 1 — "Figure 1.4. Time to first token versus tokens per second. Two numbers, two phases, two bottlenecks" — and a Chapters list containing just a Glossary where "Every term, defined once." No FAQ or price appears here.
- [Learn Harness Engineering](https://walkinglabs.github.io/learn-harness-engineering/) — This "Learn Harness Engineering" learning is just a title and a logo link right now — the only other thing on the page is "Loading...", so there's nothing to read yet. No table of contents, no FAQ, no price nugget; the page is honestly thin.
- [LLM Inference Handbook](https://handbook.modular.com/) — *LLM Inference Handbook* is "your technical glossary, guidebook, and reference - all in one," spanning core concepts and performance metrics like Time to First Token and Tokens per Second through to optimization techniques (continuous batching, prefix caching), GPU architecture, and deployment patterns like BYOC and on-prem. It's for engineers deploying, scaling or operating LLMs in production — read it start-to-finish or treat it like a lookup table — and it ships interactive calculators, simulators, and visual tools rather than just prose, with contributions welcome via the GitHub repository. No FAQ or pricing here, just the index and the motivation behind it.
- [Learn to Cloud - Your Path to Cloud Computing](https://learntocloud.guide/) — Learn to Cloud offers "a free, self-paced program" of open-source cloud engineering education, on the premise that "Information is now abundant. Access to education should be too" — "We provide the path, practice, and feedback; you bring the agency and discipline to build a lasting career." The structure is a structured curriculum with resources, practical challenges, and clear goals, automated checks and AI-assisted reviews on your submitted work, and a community when you're stuck, walking you from Linux and networking to building an AI-powered API and then deploying, automating, and securing it on your chosen cloud. Beyond that it's a thin landing page: no pricing, no FAQ, no table of contents past links to start learning at Phase 0 and explore the curriculum.
- [Invisible Details — The Art of Predictable Interfaces](https://invisibledetails.com/) — "The good stuff was never written down," so this site wrote it down: Invisible Details is two chapters — "Notes, then Practice. First, the theory. Then watching it getting applied" — covering states, feedback, inputs, speed, and the few pixels nobody talks about, like optical versus mathematical alignment. It's a one-time purchase, "forever yours," with a 40% regional price for India, and you can "read a few chapters for free" before any of that.
- [User Interface Typography — Practical Rules for Readable, Scalabl...](https://imperavi.com/books/user-interface-typography/) — A 266-page PDF book on "Creating balanced & expressive UI typography," promising to "Build modular type scales and vertical rhythm," "Compare good and bad patterns through 300+ illustrated examples," and "Apply accessibility rules for size, contrast, and state" — structured in seven chapters, from Foundations of UI Typography through Accessibility & Inclusivity, with a free preview download. It's digital-only ("No, the book is currently available only in digital format"), one-time purchase, lifetime access, at $49 Solo for individual use and $149 Team for sharing within a team or company, and "Since this is a digital product, all sales are final."
- [Laws of Software Engineering](https://lawsofsoftwareengineering.com/) — A flat index of engineering laws, principles, and rules of thumb, sorted into Teams, Planning, Architecture, Quality, Scale, Design, and Decisions, each compressed to a single line — "Leave the code better than you found it," "Work expands to fill the time available for its completion," "90% of everything is crap." That's the whole page: no explanations, no FAQ, no pricing, just the one-liners and links out.
- [Make It Animated | React Native Animations](https://makeitanimated.dev/) — A collection of React Native animations and components pulled "from Real-World Mobile Apps" — "Battle-tested patterns optimized for 60fps performance using Reanimated, Gesture Handler, Animated API & Skia" — with 70+ animations to copy and study plus reusable Loader, Shimmer, and TextStrikethrough components. It's "Recommended by Expo as a learning resource" and featured in State of React Native 2025, and "So here's the deal": US$59 one time payment plus local taxes locks in lifetime access to everything today plus future animations, with the next price at US$69. The FAQ is thin — just a contact at hello@makeitanimated.dev.
- [Typex](https://www.typex.rocks/) — Typex is about as thin as a page gets: the whole thing is one line of drill text — "⌨Tippe die Buchstaben ab" — followed by letter runs like dalk·salsa·das·flak·als·fall·alks·skala·jklö·all·fdsa·jaks·kalks·asdf·lass, a finger cue ("Linker Mittelfinger"), and a drawn-out QWERTZ keyboard from ^ 1 2 3 4 5 6 7 8 9 0 ß ´ through Shift < y x c v b n m , . - to Ctrl Win Alt AltGr. There's no table of contents, no FAQ, no pricing — just the letters and the keys.
- [Protocol Cards — Evidence-backed Nervous System Regulation](https://www.nsmastery.com/protocols) — This page is just a card index: "Protocol Cards — Evidence-backed Nervous System Regulation" lists five categories — Emergency Acute Stress ("Rapid interventions for panic, overwhelm, or acute stress moments"), Focus Performance ("Prepare mentally for calls, presentations, or difficult conversations"), Recovery Post-Stress, Sleep Wind Down, and Feel Process Emotion. The only instruction is "Click a card to explore protocols." No FAQ, no pricing, and no protocol detail — the page is thin.
- [Ship Apps & Product Features That Users Adopt Instantly](https://www.consumerapp.studio/) — A deck of 175+ tactic cards sorted into 12 stacks — onboarding, activation, retention and monetisation among them — where each card is "an emotional building block, designed to make your feature land and your app stick." It's a "huge Figma swipe file" with 99+ real app screens, and it sets you back $97: pay once, download straight away, no subscription, updates free forever — and it's "not a course. No videos. No BS." Pick a stack by priority, pull a card, ship it this week. keywords: design, ux, product, apps, figma, growth
- [Just Postgres - Your Practical Guide to Postgres](https://www.justpostgres.tech/) — Just Postgres is a practical guide offering "everything you need to master Postgres": The Book ("the modern book on the breadth and depth of Postgres capabilities"), a Blog of "technical deep dives, hands-on tutorials, and lighter reads," Recipes of "quick, copy-paste solutions to common Postgres tasks," and YouTube video tutorials. It's "created by a developer, for developers" — Denis Magda, who shares what he's learned "so you can build better applications." The page itself is thin: no FAQ, no pricing, just those four doors and a get-in-touch link.
- [Motion Graphic Design & Animation Principles Website - Zajno Digita...](https://motion.zajno.com/) — UI/UX animation "emphasizes the details to which users should pay attention," and this lesson walks through the basics of easing — linear, ease, ease-in, ease-out, cubic — plus the interactive split between real-time and not-real-time interfaces and the classic slow-in/slow-out principle, with video demos and implementation examples from Fly Dashboard, Keep and PalmPalm. It closes on "Useful courses & Sources" — 10 courses, 4 sources — under the line "You are always a student, never a master," with no pricing on the page.
- [faster.dev — AI-Assisted Development for Experienced Engineers](https://faster.dev/) — faster.dev is a training platform for software developers who want to ship more without turning their codebase into chaos, offering structured video series, field notes, project logs, and downloadable slash commands, skills, and rules you can use right away, taught by Aaron Francis ("I've been a professional software developer for over 20 years"). Membership is $299/year with a 30-day full refund, and the FAQ covers whether moving faster means lower quality ("No, that's the whole point") and which tools are covered: "Claude, Codex, Gemini, AMP, and V0."
- [Database School](https://databaseschool.com/) — Database School is "the best place to learn, understand, optimize, and confidently use databases," with 48 hours of content across 391 videos and 7 series: Durable Objects, High Performance SQLite, MySQL for Developers, Intro to Postgres, Mastering Postgres, Advent of SQL, and Convex. The pitch is practical, not academic — "Think of it as a school of thought, not a university" — with an All Access Pass at $269 USD/year, team pricing at $1,199 USD/year, and a 30-day money-back guarantee. FAQs cover pacing (videos average 7–10 minutes), free videos but no free trial, and lifetime access if you previously bought Mastering Postgres or High Performance SQLite.
- [effect.institute](https://www.effect.institute/) — Effect Institute is a wall of reader feedback — No. 7 through No. 72 — praising an interactive course on Effect: "the best tutorial format I've ever seen," "Mesmerizing way of running a tutorial," "THIS IS FRIGGIN AWESOME!" It's thin: no curriculum, FAQ, or price, just praise, a "great but add volume control pls kthxby," and one "How to support your work?"
- [Patterns.dev](https://www.patterns.dev/) — Patterns.dev is a learning site split into three tracks — JavaScript Patterns ("Patterns focused on plain Javascript and Node.js"), React Patterns ("Patterns focused on React and Next.js"), and Vue Patterns ("Patterns focused on Vue.js") — where every entry is one named pattern with a one-line promise, like "Share a single global instance throughout our application" for Singleton, "Split up your code into smaller, reusable pieces" for Module, or "Intercept and control interactions to target objects" for Proxy. The JavaScript track also covers loading and delivery concerns such as Static Import, Dynamic Import, Import On Visibility, Import On Interaction, Route Based Splitting, Bundle Splitting, PRPL, Tree Shaking, Preload, Prefetch, List Virtualization, and Compressing JavaScript, while React runs from Container/Presentational through Hooks, Compound, Client-side Rendering, Streaming Server-Side Rendering, React Server Components, and React Stack Patterns. There's no FAQ or price information on the page.
- [Metascraper: unified metadata from the web](https://metascraper.js.org/) — Metascraper is "a library to easily extract unified metadata from websites using Open Graph, Microdata, RDFa, Twitter Cards, JSON-LD, HTML, and more," built out of rules bundles ordered from most specific to most generic so each rule works as a fallback for the next. It detects audio, author, date, description, video, image, lang, logo, publisher, title and url, and its benchmark table claims 95.54% correct against html-metadata, node-metainspector, open-graph-scraper and unfluff. If you don't want to manage "headless browsers, proxies, and antibot workarounds" at scale, the fully managed Microlink API handles proxy rotation, paywalls and bot detection, with pricing that is pay-as-you-go and "starts for free."
- [Animations on the Web](https://animations.dev/) — animations.dev is "the interactive learning experience where you'll learn the theory and practice behind great animations" — four base modules (Animation Theory, CSS animations, Framer Motion (now Motion), Good vs Great animations) plus four walkthroughs (Family Drawer, Dynamic Island, Navigation Menu, SVG Animations) totaling 15 lessons, with a Discord community, curated videos and articles, expert interviews, custom easing curves and 15 AI skills as bonuses. Enrollment is closed — 13,000+ designers and engineers have taken it, the next window opens sometime in 2027 for 10 days, and joining the waitlist gets you "two free preview lessons and behind-the-scenes content every two weeks." No price appears on the page.
- [The Craft of UI](https://www.craftofui.dev/) — The Craft of UI is Jhey Tompkins's playbook of "real UI patterns, demos, and techniques you can explore at your own pace" — no lessons, no progress tracking, no linear path — where each entry starts with a real interface, pattern, or idea and breaks down what actually matters, what doesn't, where constraints come from, and how structure, behaviour, and motion shape the result, mixing foundations like animation and interaction with applied "Studio" explorations, and delivered as video walkthroughs, written breakdowns, embedded demos, and full downloadable source code. It's "a living body of work that grows" over time for anyone who has looked at a design and thought "How would I actually build that?", with a private Discord, topic requests, AI used "where it makes sense" (Zed + Claude), and the leaning on HTML and CSS fully, JavaScript when it adds real value, and libraries only when they genuinely help. It's a one-time purchase starting around $279 for lifetime access including future updates, with a full refund within 7 days by emailing refunds@jhey.dev.
- [Devouring Details](https://devouringdetails.com/) — Devouring Details is "an interactive reference manual for interaction-curious designers, containing 23 chapters with 23 downloadable React components," split into 3 units—Principles, Prototypes, and Resources—where "you'll interact with prototypes on a custom platform and be exposed to details that I pay attention to." Principles covers eight concepts (Inferring intent, Interaction metaphors, Ergonomic interactions, Simulating physics, Motion choreography, Responsive interfaces, Contained gestures, Drawing inspiration), Prototypes are deep dives into single components with downloadable source code, and Resources holds code snippets, process insights, private bookmarks and a component library. There's no pricing here beyond two FREE labels (the Next.js Dev Tools prototype and Behind scenes)—just a wall of testimonials and Rauno's Vercel/Arc background.
- [MAKING SOFTWARE](https://www.makingsoftware.co/) — This won’t teach you how to actually make software — it’s not a tutorial or a guide, but a manual that explains how the things you use everyday actually work: touch screens, Gaussian blur, Figma’s pen tool/bezier curves, rasterisation and anti-aliasing. Early Access is $99 and unfinished, with 22/31 chapters done (77.6K of an estimated 109.3K words, 848 images); the FAQ asks about AI, illustrations, launch, physical book, font, writing about x, and discounts/PPP, though every answer on the page just repeats the physical-book answer.
- [Flavio Copes](https://flaviocopes.com/access/) — "17 programming books. 87 courses. All free." — Flavio Copes gives away 17 handbooks ("Each handbook takes one topic from zero to productive. Short lessons, real code, no filler.") and 87 lesson-based courses as PDF and EPUB, earned by joining the newsletter and confirming your email: "The library opens right away. Come back whenever you want, it remembers you." The page walks through the books (JavaScript, CSS, Node.js, Astro, HTML, Next.js, React, SQL, Git, Laravel, Express, Swift, Go, PHP, Python, CLI, C), the courses, a three-step "How it works," a short "Who is writing," and a FAQ answering "Is it really free? Yes… There is no paid tier hiding behind the form and no upsell after you sign up," plus "You keep access to the library after you leave" and "It is stored on a secure server in the EU, used only for this newsletter, and never shared or sold."
- [Operating System in 1,000 Lines](https://operating-system-in-1000-lines.vercel.app/en) — Hey there! In this book, we're going to build a small operating system from scratch, step by step — context switching, paging, user mode, a command-line shell, a disk device driver, and file read/write operations in C, and "it's only 1,000 lines of code!" The tricky part is debugging ("You can't do `printf` debugging until you implement it"), but we'll learn how to debug an OS too; the prerequisites are familiarity with C and a UNIX-like environment, the implementation examples are downloadable from GitHub, and a TIP points to Hypervisor in 1,000 Lines for a Rust version.

## Inspiration

- [Best Web Design Inspiration | Details.so](https://www.details.so/inspo) — Details is focused on the parts that make great websites great: hero sections, footers, page transitions, preloaders and the micro-interactions in between. Every example is captured from a live production site, tagged by hand, and added weekly — find yours across 3,500+ examples. The more exceptional interfaces you study, the easier it becomes to recognize the spacing, hierarchy, motion and interaction choices that make a website feel considered, until those decisions become instinct.
- [Social media post design inspiration — posts.design](https://posts.design/) — “See what 1,080+ brands actually ship to socials”—posts.design is social media post design inspiration for posts, headers, OG images and more, updated daily. Join for free to browse 5,565+ posts from 1,040+ brands (44 joined today).
- [Wellmade · A home for well made creative work](https://wellmade.fyi/) — Wellmade is "A home for well made creative work" — a feed of posts where each tile opens a piece from a maker: a poster, "early identity concept," "brand identity for pera." A visitor scrolls the grid and clicks through to the work.
- [Site of Sites | The Best Web Design Inspiration 2026](https://www.siteofsites.co/?p=1) — Site of Sites is "The Best Web Design Inspiration 2026": "Explore the Best of Site of Sites," "All websites (604)," "OUR CURATED WONDERS." A visitor gets a "Product Spotlight with Yael Renous / Brik" — "building tools around ideas - and designing with more freedom."
- [Spotted in Prod — The very best of iOS](https://www.spottedinprod.com/clips) — Spotted in Prod is a collection of "The very best of iOS" — app clips you can browse by tags spanning design language (System, Minimal, Skeuomorphism, Brutalist), visual (Liquid Glass, Shader, Glow, Pixel Art), gesture (Tap, Pinch, Throw, Shake), flow (Onboarding, Paywall, Empty State, Easter Egg), pattern (Card Stack, Radial UI, Snapping Scrolling), category (Music, Crypto, Dev Tools, Astrology) and team type (Indie, Big Co, Startup). What a visitor gets is the clips themselves — "Museum by reactiive" among them — each tagged and linkable back into those indexes.
- [App Store Screenshot Design Inspiration | before.click](https://before.click/) — before.click is "app design inspiration, screen by screen" — curated App Store screenshots, onboarding, paywalls and icons from the best iPhone and Mac apps. Browse by platform or category, or sign up for "New apps every week": a weekly email with freshly added screenshots, paywalls, and onboarding flows from top iOS apps.
- [Detail · Where craft lives](https://detail.design/) — Detail is "Where craft lives" — a showcase of small interface details, each one a video clip tagged Design, Motion, Interactivity, Copywriting, Accessibility, or Easter Egg, from "Smarter Word Break" and "Smart Corner Morph Animation" to "Hold to Reveal Shortcut Hint." The takeaways are the notes under them: "A shortcuts list teaches people once. Holding ⌘ teaches them every time," or "Tell people what is expected by what they already wrote."
- [Godly — Astronomically good web design inspiration](https://recent.design/?ref=godly) — Recent is a design inspiration feed — posters of work, each credited to its maker, from Emil Kowalski and Zach Lieberman to ThisUX — Design Studio, with some entries marked "3 slides" or "4 slides" and one slot labeled "Sponsor". A visitor scrolls the stream and looks at the work.
- [Footer — The only footer gallery on earth.](https://www.footer.design/) — Footer describes itself as "The only footer gallery on earth." It's a gallery of footers — a place to look at them, curated in one spot.
- [60fps - UI/UX animation inspiration for mobile & web apps](https://60fps.design/) — 60fps is an “Endless collection of delightful details from best-in-class apps” — UI/UX animation inspiration for mobile & web apps. It shows shots and filters like Watch, 3D, AI, Apple and Assistant, including Uber Loading Animation and Apple Customize Control Center How to Animation. A visitor gets that endless collection of delightful details from best-in-class apps.
- [Mobbin — UI & UX design inspiration for mobile & web apps](https://mobbin.com/) — Mobbin is design inspiration for mobile and web apps — apps, sites, screens, flows, animations and UI elements in "One library for all your needs." It started in 2018 as Jiho's Dropbox folder of screenshots — "It's still that folder at heart, just 621,500 screens bigger" — where "Design research took hours. Now, it's one search." You can also "Give your AI agents access to Mobbin" by connecting MCP, available on Pro & Team plans.
- [Landing page examples](https://landings.dev/) — Landings shows “landing page design example”s — Crontap, Portline, Langbase, Unkey, Daytona, Ycode, Composio, Conductorai, Vite, Usepylon, Dreamcut, Attention. A visitor gets those examples, each linked to its post.
- [Navbar Gallery – Navigation Design Inspiration](https://www.navbar.gallery/) — "Navbar Gallery is a curated navigation-focused design inspiration website" where you can "find the best navigation bar examples for your design." It began with a spark of inspiration on Twitter, ignited by footer.design, after discovering there was no dedicated navigation-focused resource for designers — so it was built in public on Twitter.
- [Workspaces](https://workspaces.xyz/) — Workspaces is a free weekly newsletter, est. 2020, sending "weekly tours of real desk setups from designers, founders, and builders" every Saturday. Browse 546 setups — Daniela Muntyan, Matthew Encina, Luboš Volkov and more — each tagged by collection, from Apple and IKEA to plants, standing desks, and mechanical keyboards. As Sam DeBrule says, "Workspaces is the new MTV Cribs."

## Directories

- [Articles](https://www.vayo.me/bookmarks/cltpx1nq70001jw1tc90e4ht6) — A directory of "Articles" — a running list of links out to pieces from around the web, each shown with its title and the source's own line about it: "Friction as a Feature — A natural filter for bad ideas," "There's no speed limit | Derek Sivers," "How's Linear so fast? A technical breakdown," "Agents with Taste — How to transfer taste into an AI." The destinations are personal blogs and journals (arslan.io, rauno.me, paulgraham.com, seangoedecke.com, mamuso.dev, Invisible Details, The Squiggle), engineering write-ups (PlanetScale's "118 million queries per second on Neki," Vercel on "Framework-defined infrastructure," Cursor's "Git at any scale," Enter Blog), and notes on craft — gradients, typography specimens like Houston Mono, icon systems, and interface details. The page itself is titled "Articles."
- [Gustavo Fior](https://www.gustavofior.com/books) — This is a directory of books: cover, title, author, one after another, from Liev Tolstói's Guerra e Paz to Walter Isaacson's Leonardo da Vinci. Fiction sits beside philosophy, business, science and biography — A Revolta de Atlas, O Príncipe, The Mythical Man-Month, Cosmos — each entry just an image, a title and a name.
- [Ye Olde Blogroll - Because blogs are the soul of the web](https://blogroll.org/) — Ye Olde Blogroll is a directory of the personal web—“Because blogs are the soul of the web”—and it points to “100 manually curated entries.” Those destinations are personal blogs, personal websites, diaries, digital gardens, and “my online nook,” where people write about tech, books, photography, art, games, nature, life, and “whatever else catches my attention.”
- [Bubbles](https://bubbles.town/) — Bubbles is a directory of “Blog post:” links from source domains, each item carrying a “Log in to vote” tally. It points to blog posts from sites like davidrevoy.com, anildash.com, hughhowey.com, danq.me, and adactio.com, covering license updates, AI scrapers, static sites, city builders, far-infrared telescopes, dumbphone reviews, and more.
- [HeyDesigner — Hand-picked Design Links, Daily](https://heydesigner.com/) — HeyDesigner is a “Hand-picked Design Links, Daily” directory. It points to design articles, videos, and resources on topics like AI, typography, CSS, and UX.
- [Product design & UX design resources – Degreeless.Design](https://degreeless.design/) — Degreeless.Design is a directory of product design and UX design resources — a collection of "links, books, articles, and more" the author began gathering in design school and kept amassing to "speed boost your career." It points to destinations in four groups: Basics (design foundations, theory & principles, history), Starting UX (UX foundations, design process, research, deliverables, UI & design systems), Advanced Resources (high quality content, designing beyond screens, books on business, HCI, & more), and Inspiration. The tone is self-sufficiency: "Tools change & trends die. Master process."
- [Design Engineer Tools](https://designengineer.tools/) — Design Engineer Tools is a directory that opens with **Inspiration** — 60fps, Awwwards, Cosmos, Godly, Mobbin — then files everything else under **AI Code**, **Components**, **Web Utility**, **Desktop Utility**, **Video & Capture**, **Whiteboard**, **Organization**, **Fonts**, **Visual**, **Interface**, **Motion**, **Audio**, **Volumetric**, **3D**, **glTF**, **Digital Fashion**, **Research**, **Browser** and **Emoji**. The destinations run from Cursor, v0 by Vercel and shadcn/ui to Figma, Framer, Blender, Spline, Raycast, OBS Studio, Excalidraw and Obsidian.
- [Design Engineering](https://www.floguo.com/notes/design-engineering) — A living doc of notes and resources for design engineering — "The discipline bridging design and dev & why it matters" — gathered by Flo, "a designer who builds" who now tinkers at Paradigm as founding design engineer. It points outward to essays defining the role, agent skills and guidelines, tools like Locale and Remotion, courses he's purchased, design pattern libraries, communities, and personal perspectives. The closing notes land on the thesis: "Material understanding beats tool proficiency."
- [DesEngs: Resources for Design Engineers](https://desengs.com/) — DesEngs is a "directory" of resources for design engineers — components, tools, essays and jobs gathered around the question of "what a design engineer is." The links run from copy-paste React pieces like "Sonner • An opinionated toast component for React" and "Interior.dev • Micro-interactions for react, built for the half-second after a click," to writing on taste, typography and AI, plus job listings such as "Autumn • Founding Design Engineer / Remote, United States."
- [Books | Trails](https://trails.pieterma.es/books/) — Books is a directory of book pages on Trails, each one listed with its cover art and a count of trails: Thinking in Systems leads with 15 trails, followed by Seeing Like a State with 11, Superforecasting with 9, and Creativity, Inc. and Behave with 8 each. The list runs long from there, down to the many titles carrying a single trail.
- [Trails](https://trails.pieterma.es/) — Trails is a directory of reading trails — themed paths through books, each with its own one-line thesis, from "Self-deception as strategy: the best liars believe themselves" to "Import order constantly or dissolve into disorder." Every trail is tagged with its subjects — Blue lies, Evolutionary psychology, Self-deception; Brittle fracture, Metal fatigue — and laid over the book covers that make it up, like *The Elephant in the Brain*, *Behave*, *The Goal*, and *Titan*.
- [MCP Registry Registry](https://mastra.ai/mcp-registry-registry) — The MCP Registry Registry is a directory of directories — places to find MCP servers, from the official modelcontextprotocol/servers "collection of reference implementations for the Model Context Protocol" to aggregators like Apify ("17000+ scrapers, crawlers, and automations"), Smithery ("4,274 capabilities"), MCP.so ("Find Awesome MCP Servers and Clients") and MCP Bar ("Open Registry & Package Manager for MCP Servers"). Each listing carries a count and a tag — #official, #verified, #open-source.
- [BlogScroll - Personal Blog & Site Directory](https://blogscroll.com/) — BlogScroll is "an open directory of personal sites and blogs, maintained entirely on GitHub," made to bring attention to "little 🌱 digital gardens and ✨ personal corners of the internet" that people maintain outside the "Big Tech" walled gardens. Its destinations are grouped under design-and-ux, finance, personal, photo-video-production, and technology, with an RSS feed and OPML file to "stay up-to-date on the latest additions."
- [llms.txt directory](https://directory.llmstxt.cloud/) — A directory that lists 3,852 websites and counts "50M Total llms.txt tokens" and "414M Total llms-full.txt tokens" across them. Entries are filed under categories like AI, Developer tools, Products and Websites, each linking straight to that site's /llms.txt or /llms-full.txt (or "Not available"), with a "Recently added" feed and sponsor slots alongside. "Meet the modern standard for public facing documentation" sits among the featured blurbs.
- [Sidebar | Domain: blog.jim-nielsen.com](https://sidebar.io/domain/blog.jim-nielsen.com) — Sidebar's page for blog.jim-nielsen.com is a directory of links out to one blog's posts — "Writing about the big beautiful mess that is making things for the world wide web." The destinations it points to cover generative tool interfaces, strict visual systems, web components, view transitions, Sass in vanilla CSS, and software an automated agent can't use.

## Other

- [One Day You’ll Find Yourself](https://www.onedayyoullfindyourself.com/) — This is the landing page for "One Day You'll Find Yourself," published by © 2026 W.S. Cole Press. It offers little more than a way in: a link to its Table of Contents and a "Next Page" link, which point to the same place.
- [Sherlock Project](https://sherlockproject.xyz/) — This page is the Sherlock Project's documentation entry point, telling you to "Fetch the complete documentation index at: /llms.txt" and to "Use this file to discover all available pages before exploring further." That is the whole of it: a pointer to the index, not the docs themselves.
