Blog Posts
Search by topic, filter by category or year, and sort through the archive without losing the thread.
137 posts
AI spend caps belong in product design
As AI platforms added spend controls, it became clearer that budgets are part of user experience.
Dependencies are part of the threat model
Package choices affect security, maintenance, performance, and how quickly a team can patch.
Fresh context review is not bureaucracy
Verifier agents catch different failures when they are not soaked in the builder rationale.
SWE-bench stopped being enough
When a benchmark stops separating frontier coding systems, teams need local evals more, not less.
Product specs should name the boring states
A product spec that skips loading, empty, error, permission, and rollback states is not finished.
Multimodal embeddings made search feel wider
By 2026, embedding work was moving beyond text into image, audio, video, and PDF retrieval.
Technical writing needs room for wrong guesses
A good tutorial shows the mistake the reader is about to make and gives them a way back.
Local dev needs an exit ramp
A development loop should tell you how to stop, reset, and recover without reading every script.
RSS is still good plumbing
Feeds are unglamorous, durable, and still worth maintaining for a personal site.
Guardrails are product decisions
AI guardrails define what a product should do, refuse, explain, log, and escalate.
Math clicks when the shapes stop moving
Stable notation and repeated small examples do more for intuition than a tour through every formula.
Approval buttons need context
An approval step only helps if the human can see the plan, the data, and the rollback story.
Secret scans are cheap compared to rotating keys
A secret scanner is boring right up until it saves a weekend.
Ranking shows up everywhere
Ranking shows up in recommendations, retrieval, alerts, model routing, and engineering workflows.
Sync conflicts are interface problems
Conflict resolution belongs in the product experience as well as the replication layer.
Automation should leave a receipt
Personal automation is easier to trust when it leaves a plain record of what it did and why.
The first example carries too much weight
Readers build their mental model from the first runnable example, so that example has to be honest.
Threat analytics is time series work too
Security signals often come down to timing, baselines, drift, and knowing when a pattern changed.
o3 and o4-mini made routing harder to dodge
The o-series releases made the cheap, fast, smart tradeoff harder to avoid and better to name.
Shader toys are debugging tools too
Small visual programs can be toys and debugging tools because they make math and state visible.
Git history should explain the decision
A commit message is one of the cheapest places to preserve why a change happened.
Data contracts are where AI quality starts
Model quality work starts before the prompt when the data shape is undocumented or quietly changing.
Small model choices still matter
A short note on the small model details that still shape behavior when systems move into production.
Notes need friction in the right place
Fast capture is useful, but the real value comes from making review and reuse easy enough to happen.
Data cleaning is model work
Better data often improves AI systems more than another round of prompt tweaks.
Input validation is product design
Validation rules are defensive code, but they also describe what the product accepts as real.
Pyodide makes blog posts feel less theoretical
Running Python in the page changes a tutorial from explanation into a small lab.
Scripts should be idempotent by default
The best project scripts can run twice without making the second run weird.
Agents need boring boundaries
A practical note on agents, MCP tools, identity, permissions, and why clear limits matter.
A writing backlog should not be a guilt machine
A useful backlog stores ideas without turning every old note into a quiet accusation.
Reasoning models changed where latency belongs
The o1 preview made it easier to talk about spending extra time on hard steps instead of every step.
Why I like small agent tools
Small tools are easier to permission, easier to review, and harder for an agent to misuse quietly.
Visual examples should earn their space
A diagram helps when it lets the learner predict the next step, not when it decorates the page.
Evals are how AI teams stay honest
A simple note on using evals to catch regressions before users find them.
Astro content is a real interface
Static content systems still need schema discipline, naming conventions, and boring build checks.
Good CLI output is a kind of API
Terminal output should be written for the person debugging at 11 p.m., not for the happy path demo.
Agent runbooks need failure examples
Runbooks for agents get better when they include the mistakes the agent is expected to make.
TypeScript 5.5 cut some friction from filter code
Inferred type predicates were not flashy, but they removed a small daily tax from TypeScript code.
Embeddings are product plumbing
Embeddings are useful because they make search, memory, deduping, and retrieval feel less brittle.
GPT-4o made multimodal product work real
The GPT-4o launch made audio, vision, and text feel like one product surface instead of three demos.
SQLite in the browser changes the default
When local databases become easy to ship, small tools can keep more state close to the user.
Kubernetes 1.30 was an upgrade planning reminder
Kubernetes releases are a calendar discipline that reaches beyond cluster administration.
Batch processing stops the lesson from lying
Why running several inputs at once gives a more honest picture of what a model is doing.
Feature flags are product memory
Flags are rollout switches, but they also record uncertainty, ownership, and the path back.
Gemini 1 arrived with a multimodal reset
Google's Gemini 1.0 launch made the next model fight feel multimodal, tiered, and product-shaped.
Design tokens need owners
Tokens are useful only when somebody owns the meaning, migration path, and exceptions.
No posts match those filters.