Matt Rickard
About Matt Rickard.
- Posts
- 945 from 14 May 2023 to 21 Jul 2026
- Posting
- monthly (8 in the last year)
- Kind
- personal blog
- Feed
- https://mattrickard.com/rss
2026 8
2025 1
2023 151
- Pseudonyms in American History
- Fairchildren
- ChatGPT After One Year
- McNamara Fallacy
- Data Quality in LLMs
- Discord and AI GTM
- Standard Causes of Human Misjudgment (Munger)
- The Unreasonable Effectiveness of Monte Carlo
- Razor and Blades Model
- Drawbacks of Moving to the Edge
- Are Things Getting Worse?
- How AI Changes Workflows
- Duties of a Board of Directors
- Strategies for the GPU-Poor
- Take Your Time Making Decisions
- The Encyclopedia of Integer Sequences
- The Catilinarian Conspiracy
- The Model is Not the Product
- The AI-Neid
- Model Merge - (Frankenmerge)
- The Cost of Index Everything
- What if Google Wasn’t The Default?
- Copilot is an Incumbent Business Model
- Eroom's Law
- The Lucretius Problem
- The Call to Adventure
- AI Agents Today
- Norvig's Agent Definition
- The Context Length Observation
- To be, or not to be; ay, there’s the point.
- Improving RAG: Strategies
- Static Sites Aren't Simple Anymore
- Lessons from llama.cpp
- Why Model Evaluation is Difficult
- Mechanical Turks
- Regulatory Capture in the Railroad Industry
- What If OpenAI Builds This?
- On Mixing Client and Server
- Infrastructure as Code Will be Written by AI
- When A/B Testing Doesn't Work
- Between Images and Text, CLIP
- Positioning Yourself Near the Opportunity
- Tech Invariants
- Horizontal Tuning: Instruction, Chat, and What Else?
- Retrieval Augmented Generation
- The Silent Todo List
- Pitfalls of File-based Routing
- Benefits of Small LLMs
- Can OpenAI Win Consumer and Enterprise?
- The Inner-Platform Effect
- Revision: Generative text-to-UI
- Why Is the Frontend Stack So Complicated?
- An Intelligent Wikipedia
- The Half-Life of the AI Stack
- Nagle's Algorithm
- Black Swan by Shakespeare
- Anticipate the Cheap
- Moravec's Paradox
- The American Experiment
- Incentives Behind Programming Languages
- 3D as the New Modality
- Keep Going
- The Benefit of a Personal Notation
- Pitfalls of Database Migrations
- Generative Interfaces
- Lessons From Debugging
- Compression / Learning Duality
- Is AI a Platform Shift?
- Passkeys, Crypto, and Signing AI Content
- Is Data Still a Moat?
- Multi-Modal AI is a UX Problem
- Observer-Expectancy at Scale
- LLMs as System 1 Thinkers
- The Fundamental Attribution Error
- Good Enough Abstractions
- Automate (But Automate Last)
- AI Biographers
- Customized End User Software (with AI)
- Five Principles from Renaissance Technologies
- Moving Upmarket
- The Age-old Resistance to Generated Code
- Cincinnatus
- Undetectable AI
- The New Economics of Generating Code
- The Inevitability of Scope Creep
- Fine-tuning Stable Diffusion XL with Personal Photos
- The Low-Hanging Fruit
- Beyond Prompt Engineering
- The Hardware / Software Cycle
- Raft: The Distributed Systems Algorithm
- The Widgetification of Apple
- Type Constraints for LLM Output
- Why Fast?
- Technical Metrics to Track in Engineering Orgs
- TypeScript Type System Hacks
- Capital Intense AI Bets
- Imputavi, Computavi, Putavi.
- Llama 2 in the Browser
- The Contrarian Strategy of OpenAI
- GitHub Inbox as GTM
- AI and Text-First Interfaces
- The Business Source License
- The Free Lunch of Model Distillation
- Adding Constraints
- Copy and Paste Libraries
- Beating the Average
- A Model API Gateway for 20+ LLMs
- De Facto Ports
- The Truth About GPU Utilization
- Directly Responsible Individuals
- Akin's Laws of Spacecraft Design
- What is a Prompt Engineer?
- Learning Via Negativa
- Why Tailwind CSS Won
- My Everyday LLM Uses
- Dark Mode and Marginal Benefit
- Llama/Unix
- Deterministic, Structured LLM Output
- Bayes' Rule
- A Fine-Tuning Marketplace
- Majority Rule Developers
- NVIDIA's CUDA Monopoly
- Prescriptive vs. Descriptive Feedback
- Focus On What Could Go Right (Not Wrong)
- Apple's Hidden Social Network
- Data Versioning
- Automatic and Universal Adversarial Prompts
- Minimum Effective Dose and Discrete Outcomes
- On Compounding
- Git Merge Strategies and Algorithms
- Modern Samizdat Libraries
- Amara's Law
- Black Swan Theory
- Optimizing $Model.cpp
- Commonplace Books
- Virtual Machines and Path Dependence
- On Getting Married
- The RLHF Advantage
- Robots.txt for LLMs
- Why Did Meta Open-Source Llama 2?
- Diffusion of Innovation
- Literate Programming with LLMs
- Schopenhauer's 36 Stratagems for Winning Arguments
- Scale to Zero for AI Workloads
- Stop Overengineering
- Hard Launches vs. Soft Launches
- Virtualized Linux on macOS Internals
- Why Frameworks Fail
- Categorization and Classification with LLMs
- Towards Technical CEOs
- ReLLM: Exact Structure for Large Language Model Completions
Undated 785
- most popular
- ActivityPub, Decentralization - Do Users Care?
- The Anti-AI Movement
- Customer Obsession is the Only Winning Strategy
- Avoiding Footguns
- Where AI Fits in Engineering Organizations
- Myths About ORMs
- Google Search's Death by a Thousand Cuts
- The Circular Startup Economy
- Personal Lessons From LLMs
- Overcoming LLM Hallucinations
- Monopolizing Useless Resources
- Dark Patterns
- Platform Engineering vs. DevOps
- Model Evaluation is (Still) An Art
- Clear, Simple, and Wrong
- What Comes After Kubernetes?
- No Feature is Free (Especially AI Ones)
- Mixture of Experts: Is GPT-4 Just Eight Smaller Models?
- The LLaMA Ecosystem
- Merge Queues
- Unforced Errors
- The Low-Background Steel of AI
- Why Does Every AI Cycle Start With Chat?
- A Token Efficient Language for LLMs
- Keep The Main Thing The Main Thing
- ControlNet QR Codes
- It’s Too Early To Call Winners in AI
- The Last Innings of Web 2.0
- Biography of an Idea
- The Myth of the AI Infrastructure Phase
- LLMs For Software Portability
- ChatGPT Plugins Don't Have PMF
- Levels of Autonomy in AI Agents
- The Problem with Tokenization in LLMs
- What Diffusion Models Can Teach Us About LLMs
- Sequence and Version Control Models
- Practical Dependency Management for Developers
- The End of Public APIs
- Faster Horses: AI Products That Companies Think They Want
- Templating Magic Isn't Free
- AI Means More Developers
- Two Years of Daily Blogging
- Prompt Engineering is Configuration Engineering
- SEO Inside AI
- A List of Things I Was Wrong About
- The ChatGPT Plugin Specification
- The Local Development Story
- Twitter and the Idea Maze
- The New Tax on Engineering Against the Grain
- Piecewise
- On Regulating AI
- On Device AI?
- A List of Leaked System Prompts
- Intercloud Brokers
- React LLM: Run Models in the Browser with Headless Components
- Context-Free Grammar Parsing with LLMs
- Taylor Swift and Launch Cadence
- StackOverflow/ChatGPT
- Self-hosted Compilers and Bootstrapped AI
- Unix Philosophy for AI
- Why Declarative Build Systems Aren’t Popular
- The New AI Moats
- On-Demand Package Manager
- Second-level Thinking
- Llm ts
- The Python Family of Languages
- WebGPU and the New OS
- Applications of Category Theory
- Implementing LLMs in the Browser
- React Component as the API
- Why Multi-Cloud Failed
- Principle of Least Astonishment
- Probabilistic Data Structures and LLMs
- 16 Lessons from the Tanenbaum–Torvalds Debates
- Tanenbaum–Torvalds Debates, Part 1
- The ptrace syscall
- Building a Kernel From Scratch
- Autonomous LLM Agents Are At Least 10 Years Out
- Peanut Butter Manifesto (2006)
- Sandbox Your Prompts
- Stochastic/Deterministic
- Jevons Paradox and LLMs
- Everyday Fourier Transforms
- On The Shortness Of Life
- Synthetic Data From Compilers
- Foundational Models Are Not Enough
- Imperative, Declarative, Interrogative, and Exclamatory Interfaces
- But / Therefore
- A List of 1 Billion+ Parameter LLMs
- No GPUs before Product-Market Fit
- The Path Dependence of YAML
- Buyers in the Foundational Model Stack
- Internet Magic Numbers
- A High-level LLMOps Architecture
- Reasons To Do a Startup
- The Automation Frontier
- Why Open-Source a Model?
- Consumption Pricing Units in AI
- Reflections on 10,000 Hours of DevOps
- The AI Partnership Race
- A Hacker's Guide to LLM Optimization
- Kubernetes as a Dev Tool
- Code, not Chat, in Generative AI
- Distributed Systems and AI
- Necessary Conditions for an App Store Monopoly
- Remix Culture
- Are Incumbents Accruing All The AI Value?
- Model Arbitrage
- Modeling Context Length vs. Information Retrieval Cost in LLMs
- Framework-Defined Infrastructure
- The Missing Semester of CS
- The Value of Software Generalists
- Foundational Models Are Commodities
- On OpenAI's Kubernetes Cluster
- Choosing the Right Model
- Gell-Mann Amnesia
- On Prompt Injection
- Local LLaMA on a Mac M1
- Automatic1111 and AI Aggregators
- All the -Ops
- Chain of Thought Paradigms in LLMs
- Data Local Machine Learning
- On React.js
- Applications, Services, and Workflows Overload
- Will The AI Stack Be Open Or Closed?
- The Stoic Arrow
- Product Windows
- ChatML and the ChatGPT API
- The Bundling of the Software Developer
- Shells and Distribution
- More Art than Science
- Wrong Sequences For Startups
- Commoditization of Large Language Models: Part 3
- Taxonomy of Startup Risk
- The Connectors/Loaders Trap
- Erdős Vocabulary
- Why DSLs Fail
- Amdahl's Law and Optimization
- Why Python Won't Be the Language of LLMs
- Nix Is Fighting The Last War
- Interfaces for Uncertainty
- Why ChatGPT Needs AuthZ
- Ask Yourself Dumb Questions
- Carrying a Dozen Problems
- Blurring Language Boundaries
- LLM Ops, Part 1
- What Won't Change
- Multi-Model vs. Multi-Cloud
- Should OSS Projects Have Telemetry?
- Reactive Strategy
- Docker Without Docker
- Applications of Gall's Law
- Composable Models
- Stack Shift
- If It Doesn’t Ship, It Doesn’t Exist
- Optimal Stopping Theory
- Future is Not Evenly Distributed
- Zero Interest Rate Policy Phenomena
- The Frontend Bundling Cycle
- Type-Safe API Calls: tRPC vs. gRPC
- Overview of GPT-as-a-Backend
- Eisenhower Priority Matrix
- What Doesn't Fit in Git
- Cloud Services Ranked: Build vs. Buy
- Workflow Engine Paradigms
- Prompt Engineering Shouldn't Exist
- GPT Lineage
- How to Version an API
- Cheap UIs
- Cloud Spend Breakdown
- Rebuilding in Rust
- All Models Are Wrong (But Some Are Useful)
- The Problem with Drag-n-Drop Infrastructure
- Output vs. Outcome
- Garbage In, Garbage out?
- Winning Ugly and The Metagame
- Minix and nanoGPT
- Fully Managed Infrastructure
- Lessons from the Last AI Cycle
- White Space
- Fine-Tuning an OCR Model
- Semi-Organic Growth
- What's Next After NextJS
- RPA: The Human Interface
- The Implications of More Developers
- Counterfactuals
- A New ML Stack
- Top Posts of 2022
- 2023 Predictions
- Local AI: Part 2
- Local AI: Part 1
- Reflections on 2022 Predictions
- Proebsting's Law
- Turing Social: Twitter, For Bots
- Christmas 2022
- Shortest Time-to-Launch
- Software Rewrites
- Backward Compatibility
- ML Developer Experience
- The Architecture of Mastodon
- How Did Microsoft Win Back Devs?
- Vector Search
- The Fall of Freenode
- Docker as a DevTool Platform
- AI-driven Interfaces
- LAION, The Pile, and more datasets
- Abstracting the Infrastructure
- Lessons from Lensa
- Tarpit Ideas
- An Ideal CI/CD System
- Elo Rating
- Spam Filtering AI Content
- Google Takeout and Data Portability
- Stack Overflow Bans ChatGPT
- Will LLMs Disrupt Google Search?
- The Frontend Ouroboros
- A Conversation with ChatGPT
- Apple's Enemies
- MacGuffin
- Do Cold Starts Matter?
- Sharing a Notebook
- Fuzzy Databases
- Human-in-the-Loop and Other AI Mistakes
- Technical Posts Overview and Roundup
- Schelling Point
- Showing Up Every Day
- The Cloud Tax Implications
- Why Do Configuration Changes Cause Outages?
- Excel for Developers
- Will Twitter Fail?
- Generative AI Value Chain
- Amazon's Distributed Computing Manifesto (1998)
- Windows Subsystem for Linux
- Solving the Simple Case
- On the Mastodon Experiment
- On Launching
- LLMs for Code
- What is a Token? A Technical Explanation
- On FTX
- Information Barbell
- What are Containers?
- Decoy Effect
- What Happens to Infra Engineers?
- Generational Advantages
- UGC: User-Generated Code
- Mastering the Command Line
- Man in the Arena
- Who Pays? The Twitter Blue Check
- What If Google Builds This?
- Facebook's Culture Book (2012)
- And Yet it Moves
- Deploy Early, Deploy Often
- Ethereum RPC as a Service
- The Inner Dev Loop
- Apple's Ad Positioning
- Daily is the Product
- Kubernetes Interfaces
- Moat By Induction
- Exploiting Protocols for Fun
- AI Will Write Most Code
- Cloud Repatriation or Not?
- AI Scaling Laws
- Richard Feynman and Narrative
- SEC, Gensler, and Crypto
- Defaults
- Getting Stuck in the Past
- Short Taxonomy of Open-Source Strategies
- The Middle Squeeze
- A Personal Training Corpus
- Why Is NixOS Popular Again?
- Where Logic Lives
- On Web Clipping
- Risk vs. Uncertainty
- eBPF File Watching
- Reentrancy Attacks
- Perceptual Hashing
- Free Compute and Replit
- Screenshots as the Universal API
- The Steffen Boarding Method
- The Promise of Write Once, Run Anywhere
- Why Stadia Failed
- Thoughts on GitHub Actions
- Simple Group Theory
- Is Ethereum a Dumb Pipe?
- Startup Ideas I've Considered
- Hard to Compute, Simple to Verify
- What's an MVP in 2022?
- Infrastructure Defined Software
- Tree Shaking
- Rust, C++, or Carbon?
- It's Just a Tarball
- Standards, Protocols, and Platforms
- Is GitHub a Social Network?
- Google Infra For Everyone Else in 2022
- Adobe/Figma
- When To Roll Your Own X
- The Inventor's Paradox
- GraphQL Trades Complexity
- TensorFlow vs. PyTorch
- Recursive-length Prefix (RLP)/Simple Serialize (SSZ)
- SQLite Doesn't Use Git
- Materializing Results
- The Lost Art of System Administration
- Performance Comes Last
- Two Approaches to Prompt Engineering
- WASI vs. WASM
- Libraries > Languages
- Parallelizing Programs on the Blockchain
- The Unbundling of Twitter
- Low-end Disruption of AWS
- Why Does Google Kill So Many Products?
- The Commoditization of Large Language Models: Part 2
- Design in OSS
- Timeline of Early Email
- It's Harder to Read Code Than Write It
- Developer Platform Table Stakes
- The Value is in the API
- Value Accrual in the Crypto Infra Stack
- A Short List of Cognitive Biases
- r/K Startup Theory
- Tool-driven Scientific Revolutions
- Webhooks Aren't So Bad
- The Issues with Buildpacks
- Friction as a Proxy for Value
- Tradeoffs in API Design
- Teams, Slack, and Discord in Retrospect
- Cloud Native Localhost
- Towards Granular Compute
- The Ethereum Merge
- The Unreasonable Effectiveness of Makefiles
- Growing the Pie
- Developers Should Deploy Their Own Code
- Sanctioning a Smart Contract
- Braess's paradox
- Component-driven Markup
- On Unoptimizing
- Will v8 Isolates Coexist With Containers?
- The End-to-End Principle in System Design
- Sufficiently Decentralized
- Open-Source and Quadratic Funding
- The New Wave Frontend Toolchain
- Gacha Game
- A First-Class Language Package Manager
- Brooks in Reverse
- Don't Be Scared of Cloud Lock-in
- Lisp and Spreadsheets
- Adverse Selection Examples
- Defensible Machine Learning Model Naming
- Fault-Tolerant Design
- Non-Obvious Docker Uses
- Pull Request is Now the Unit of Review
- Presentation Next to Code
- Choosing Esoteric Technology
- The Quick Uptake of ARM on Cloud
- Stacked Pull Requests
- Shannon's Demon
- IaC: Strength or Weakness for Cloud Providers?
- Sybil Attacks on Airdrops
- The Story of CP/M
- Hotelling's Law and Differentiation
- Distribution in a Downturn
- The Remix IDE
- SSH: Less Relevant In the Cloud
- So Easy You Could Run It Yourself
- Smart Contract Immutability
- Not Even Wrong
- How Kubernetes Broke Git
- Commoditization of Large Language Models
- What Comes After Git
- A Look Into My Development Stack
- Giving Up Decentralization: Scalability Trilemma
- Does Financial Policy Matter?
- The Centralization of dYdX
- 16 Bell-Curve Opinions on Engineering
- History of Version Control Systems: Part 3
- History of Version Control Systems: Part 2
- History of Version Control Systems
- Asset-lite in an Asset-Heavy Business
- Sequencing
- Panic of 1907/2022
- How to Use GitHub Copilot Effectively
- Least Common Denominator APIs
- Every Sufficiently Advanced Configuration Language is Wrong
- Is Snowflake a Platform?
- Plaintext Protocols
- Thoughts on RSS
- Convergence of DBaaS and BaaS
- Path of Least Resistance
- Don''t Use Kubernetes, Yet
- The Last Question
- The Cost to Participate In Decentralized Networks
- Work Expands to Fill the Space
- Web3's Eternal September
- Are Platform Teams Dead?
- The Surprising Linearity of GitHub Star Growth
- The Centralization of Skype
- Usage-based Pricing in a Downturn
- Fallacies of Distributed Systems
- Datadog's State of Serverless
- The Idea Maze
- A Napkin Architecture of Ethereum Interfaces for Developers
- Product Velocity of Alternative Cloud Platforms
- Programming to the Interface
- Interface Decomposition in Cloud
- Payment for Order Flow in Web3
- One Year of Daily Blogging
- ETL vs. Platform Extensibility
- Computer Tips For Everyday People From a Software Engineer
- Text to Image Diffusion Models
- List of All Oblique Strategies
- A Universal Package Manager
- Smart Contract Language Runtimes
- A Short Primer on eBPF
- Crypto Without Blockchains
- Streaming Applications
- Minsky Cycle
- SQLite Renaissance
- PaaS Design Principles
- The Problem of Sharing Code
- Stablecoin Depegging
- Why Did Heroku Fail?
- Null Programming Philosophy
- Future of Passwords
- Request for Product: Typescript Docker Construct
- The Economics of Seinfeld
- Code Managed Service is Coming For Static Sites
- Taking on Good Technical Debt
- Elevator Data Structures and Algorithms
- API Aggregators Aggregating Aggregators
- Correlation vs. Causation
- Miner Extractable Value
- {Java,Py}Script
- The M:N API Problem
- Ethereum Transaction Fees
- Steganography
- What's Holding Monorepos Back?
- Path Dependence
- Improving Twitter
- Merkle Trees
- Innovation Tokens
- Permissionless Reckoning
- Chekhov's Gun of Product Development
- Why Do Protocols Win?
- Serverside, or Clientside WASM?
- Less Sticky SaaS
- Only the Paranoid Survive
- Stitching Together SaaS
- Annus Mirabilis
- Schema-driven Development
- Cathedral and Bazaar Startups
- Accidentally Turing Complete
- Why So Many Outages?
- Language Server Protocols
- Plan9: Everything is (Really) a File
- Every Unix Command Becomes a Startup
- Backwardation and Contango
- Shift Left: Observability at the Edge
- NFT and Email Spam
- Scaling Ethereum: Horizontal/Vertical
- Zero Knowledge Proofs
- Configuration-to-Code
- Engineering Against the Grain
- Type 1 and Type 2 Errors
- $ make docker
- Lagging vs. Leading Indicators
- On Standardized Tests
- Threat of the Hard Fork
- Elliptic Curve Cryptography for Beginners
- Carthago Delenda Est
- Build-as-Code
- How to Negotiate a Car Lease
- SaaS is the New Microservices
- Working on the Right Problems
- Trends from The Enterprise 30
- Embrace. Extend. Extinguish.
- Gall's Law
- Developer Velocity
- API Warfare
- Problems with Daylight Saving Time
- GitHub Isn't About Code
- youtube-dl and Google
- Sword of Damocles
- Blockchain Trade-offs: Part 3 – Incentives
- Blockchain Trade-offs: Part 2 - Privacy
- Blockchain Trade-offs
- Exponential Trends
- Ignore Sunk Costs
- Environment Parity
- Wire Protocols and APIs
- SPAs weren't a mistake
- Latency Numbers You Should Know (2022)
- What is SWIFT?
- Modus Tollens
- Giving It Away For Free
- Year 2038 Problem
- Software Convention in Consistency
- Why First Mover Advantage is Overrated
- Squash, Merge, or Rebase?
- Remote Work Zealotry
- J-Curves
- Don't Ship an Architecture
- Total Cost of Ownership and Crypto
- Order of Magnitudes
- Regression to the Mean
- Spectrum of Reproducibility
- Shodan and Port-Knocking
- What is Dog Fooding, Fish Fooding a Product?
- Compiled Configuration Stack
- Cutting Out the Middleman
- Algorithmic Fairness
- Why TypeScript for Infrastructure?
- Rickard's Law of Eponymy
- Optimization is Fragile
- VA Linux
- Platform vs. Publishers
- Onion Futures Act and Saturated Channels
- Commoditized Trust
- Meta on Meta
- Behind the $325mm Blockchain Hack
- Rethinking the PDF
- Okta's 2022 Business at Work
- Keynesian Beauty Contest
- Building the VPC Layer for Cloud
- Software Half-Life
- Flying-Car Syndrome
- Dumb (and Free) Interchange
- Source Code Generation
- The Declarative Trap
- S3 Isn't Getting Cheaper
- Negative Value Features
- Software Mullets
- Embedded DevOps Teams
- Antitrust Opportunity
- Technical Perfection and Irrelevance
- Layer Above, Layer Below
- Monk's Window
- Notes from Behind the Cloud
- Best Tech Acquisitions of All Time
- Code or Issues in DevOps Platform(s)?
- AWS is Not a Dumb Pipe
- Reversing the Chicago River
- Veto Power and Decision-Making Process
- Too Cheap to Meter
- Maxwell's Equations and Bridges
- The Story of Adobe
- Wordle: What''s the Best Starting Word?
- Losing Sleep Over Java
- VPN as a Dev Tool
- Strategy Beyond Markets
- Pair Programming Doesn't Scale
- Increasing Bus Factor
- Antifragile in 2022
- 2022 Predictions
- Expert Networks
- Open Customer Data
- Russell Conjugation and The Great Rebranding
- Developer Network Effects
- Virtual Reality this Christmas
- Capturing Digital Identity
- Ownership in the Twenty-First Century
- Lost Art of Arch Linux
- Hunting Bugs with Bisect
- Twitch's Gini Coefficient
- Antiwork
- The Real Fix for Log4j Isn't a Patch.
- Next-Gen Terminals
- No Brown M&M's
- Top 10 Posts of 2021
- 90% of Everything is Crap
- Unused Gift Cards are Great Business
- Metaverse and Other Words from Science Fiction
- Is Open Source Free Riding Bad?
- U-Shaped Utility of Monorepos
- The Leopard of Kilimanjaro
- Toolchain Sprawl
- Hollywood Accounting
- Direct Registration System (DRS)
- The Toyota Production System
- It's Impossible to Design a Watch that Only Tells Time
- If It Can Be Compiled, It Will Be
- Every DevOps Company is an Observability Company
- The Most Entertaining Outcome is the Most Likely
- Jane Jacobs and Software Engineering
- On Centralization
- Achilles and the Tortoise
- Calculating Willingness to Pay
- Browse Now, Pay Later
- Netlify, Vercel, and AWS Amplify
- Cloud Marketplaces
- The Sailing Ship Effect
- Shortcomings of Diff3
- How Git Merges
- The Gordian Knot
- How to Comment Your Code
- The Terrible UX of Git
- Being Wrong on Hacker News
- GitHub's Missing Package Manager
- The Collision Course of Databricks and Snowflake
- Mining Crypto on My M1 Max
- No Time to Read Bad Books
- The Goat Behind the Door
- A Browser for Developers
- How to Beat Google Search
- Open Infrastructure
- Open-sourced GPT-J
- Product qualified leads
- Where is the Edge?
- The Cloud Cost Era
- The Next Design Systems
- Rich Barton and Zillow
- Commodity SaaS
- Niche Communities
- I Miss The Programmable Web
- Chesterton's Fence
- Cloud Growth in 2021
- Founder Vision
- Technical Wedges
- Data Planes and Control Planes
- Kelly Criterion
- Remote Work for Developers
- Solving Supply Chain with a Tweet
- How Complex Systems Fail
- Scoping Developer Tools
- IDE as a Platform
- Agent vs. Agentless Future
- A Short History of the M1 Chip
- Zuckerberg on Platforms
- Alternative Data on Developer Products
- Top-Down JAMStack vs. Cloud
- The GitLab Upgrade
- Takeaways From JetBrain's Developer Survey 2021
- Templating: When to Move Along the Heptagon
- Kubernetes in the Data Stack
- Calculating SaaS Retention
- The Tarpit
- The Changelog Podcast #463
- Open Source Reckoning
- Running Fast
- What is BGP?
- The Birth & Death of JavaScript
- Sales Compensation at GitLab
- Zawinski's Law
- Egregious Egress and Disruption
- The Puzzling Corporate Archaeology of MIPS
- What is RISC-V?
- Extending Applications with WebAssembly
- A Hypothesis is a Liability
- Go-to-market Strategy
- Developer Experience
- Knuth and McIlroy Approach a Problem
- Commoditizing Your Complements in the Cloud Era
- A Public Public Company
- The Unbundling of the Software Developer
- The Problems with "Cloud-Prem
- Thinking Like a Contrarian With Counter-Positioning
- Remote Developer Environments are Cool Again (Kind of)
- Laws of Software Evolution
- Infrastructure as SQL
- The Data Stack As a Snowflake
- How to Calculate a CIDR
- Email is Back in Vogue
- Net Dollar Retention
- Frustrations of Modern Development
- Software Treadmills
- The End of CI
- Ten Things I Look For In a Code Review
- The Mother of All Demos
- As We Thought
- The Rule of 40
- Tools as Code
- Are Ideas Getting Harder to Find?
- Product-Led Sales Efficiency at GitLab
- Different Types of Software Containers
- An Overview of Docker Desktop Alternatives
- Your Integration Tests are Too Long
- SaaS Isolation Patterns
- Buying IPv4 Addresses
- Unknown word list
- The Clever Hans Effect
- Incremental Compilation in Build Systems
- The Map is Not The Territory
- What Low-Code Lacks
- Keep Your API Surface Small
- Nine Circles of Dependency Hell
- History of Silicon Valley: 1891-1956
- Potential Energy in Startups
- Tracking Cyclomatic Complexity
- Hire for slope, not Y-Intercept
- One Month of Using GitHub Copilot
- DRY Considered Harmful
- Yak Shaving
- Cheap and Expensive
- Non-Consensus Right
- Signaling Against Asymmetric Markets
- Growing Your Open Source Project: Part 3 – Users
- Growing Your Open Source Project: Part 2 – Community
- Growing Your Open Source Project: Part 1 – Contributors
- Service Reliability Math that Every Engineer Should Know
- Coding Classical Latin
- Confessions of an Internal Tool Builder
- Unexpected Developer Trends
- Real Options Valuation
- Silence Dogood and the Ben Franklin Effect
- Reflections on 10,000 Hours of Programming
- Economics of Bundling and Unbundling
- Limiting Steps
- How Multiplayer Data Structures Work
- Grok
- Don't Break the Chain
- Kubernetes Maximalism
- How to Spot a Made Up Number
- The IKEA Effect in Software Development
- Why The Dow Jones is a Lousy Index
- Functions as a Service
- Orthogonal or Parallel Problems
- Be Lazy
- Open-Source and Firm-Specific Training
- In Defense of the Jupyter Notebook
- Code Poems
- Ship Thesean Software
- A History of ''Welcome, seriously'' Ads
- A Personal Internet
- Everything is a Graph
- The Potato Paradox
- Package Managers and Developer Productivity
- JEDI Mind Tricks
- GitHub Copilot
- Avoiding People at Work
- Strange Loops
- The Taste Gap
- Dynamics of Switching Costs
- High-Velocity Decision-Making
- Makers of Patterns: Part 2
- Maker of Patterns: Part 1
- What is WebAssembly?
- What is MicroSaaS?
- Jevons Paradox and Software Efficiency
- Steven P. Jobs and Pixar Employees Buy Pixar
- Survivorship Bias
- Code Transparency
- Machine Learning Operations (MLOps), Convergent or Divergent?
- Foundational Products
- How Startups Grew by Platform Hacking
- Live Programming
- Reducing Errors in Decision-Making
- First Principles
- Platform Advantage: Velocity
- The End of Per-node Pricing
- Software Wants to be Simple
- Observations of the Lindy Effect
- Everything is a Browser
- Declarative vs. Imperative
- Diseconomies of Scale at Google
- Asynchronous Communication
- The Post-Modern Web
- Why Developers Will Win the Creator Economy
- Build a Team of Rivals
- Comparative Advantage and Why PMs Shouldn't Write SQL Queries
- The Case For XCode Cloud
- Problem Solving Techniques from Math
- Getting to Market With Rails
- The Developer Economy
- APIs Will Disrupt Rpa. This Is Obvious to Engineers.
- Organic Cloud Infrastructure
- Usage or Subscription Pricing
- Docker Is a Compiler
- Inorganic Growth at Zynga
- A Mind at Play
- What's Measured Gets Managed
- Why Do Companies That Sell APIs Have Such Low Churn Rates?
- ScapeNet: Real-time object detection in RuneScape
- Docker Merge
- Sales Calculus, Part 1: Scaling
- Is Technology Making Us More Productive?
- Virgo: a Graph-based Configuration Language
- The Negative Operating Cycle
- Reproducibility in Practice
- 6 Open Source Licenses That You Shouldn't Use
- An Alternative to the Dockerfile
- The Heptagon of Configuration
- Should Your Developers Work in the Cloud?
- Fast Kubernetes Development with File Sync and Smart Rebuilds
- Offline is a Feature, Not a Product
- Unit Testing with the Kubernetes Client Library