Notes on building software.
Field notes from the studio - how we design, build, and ship, and the decisions behind our apps. Filter by topic or search to find what you need.
Your app depends on a model with a retirement date
Every model you build on has a published expiry. Eight Claude model IDs stopped serving requests in the last year - here's how to make the swap routine.
Multi-tenancy: how to choose before it's expensive to change
Shared schema, database-per-tenant, or sharded? The deciding factor isn't cost - it's what happens when one customer needs something the others don't.
MCP is stateless now: what the 2026-07-28 spec changes
The new MCP spec deletes the initialize handshake, sessions, and resumable streams. Your server becomes an ordinary HTTP service - and scales like one.
What the EU AI Act actually requires on 2 August 2026
On 2 August the AI Act's transparency rules and its fines both switch on. The high-risk rules didn't - they slipped to 2027. Here's what really applies.
The unit economics of an AI feature
Token prices fell ~50x a year, yet AI bills keep climbing. The thing that costs money isn't a token - it's a task, and agentic tasks use 1000x more of them.
How to scope an MVP when building is cheap
An MVP isn't a small product - it's the smallest thing that can kill your riskiest assumption. Pendo found 80% of shipped features are rarely or never used.
AI writes code faster than you can review it. Now what?
AI generation exploded, but human review capacity didn't. LinearB's 8.1M-PR study shows the bottleneck moved from writing code to verifying it.
Background agents: AI that finishes the job after you close the tab
Agents now run for hours at coin-flip reliability. That's why AI is moving from the chat box to durable background workflows that survive crashes and retries.
Your AI agent writes code. Where does it run?
The moment an agent executes code built from untrusted input, prompt injection becomes remote code execution. Here's how to sandbox agent code safely in 2026.
Fine-tune, RAG, or prompt? Reach for them in this order
Prompting changes instructions, RAG changes knowledge, fine-tuning changes behavior. Prompt first, add RAG for your data, fine-tune only when both fall short.
Observability: logs vs metrics vs traces, and what you need
Metrics say something's wrong, logs say what happened, traces say where. You need all three - emit them with OpenTelemetry, then control cost at the pipeline.
Getting reliable JSON out of an LLM (stop parsing hope)
Prompting for JSON fails 5-10% of the time; schema-enforced structured output is ~100% valid via constrained decoding. Use it, and still validate in code.
AI-native vs AI-as-a-feature: which are you building?
Remove the AI - does your product still work? If yes it's a feature; if the business collapses it's AI-native. That gap decides defensibility, not the model.
Just use Postgres: one database instead of five
Postgres plus a few extensions now covers search, vectors, queues, documents, and jobs. Add a specialized system only when a real bottleneck forces it.
Prompt injection is the new SQL injection - but unsolved
Prompt injection is OWASP's #1 LLM risk. It shares SQL injection's root cause - data becoming commands - but has no parameterized-query fix. So you contain it.
WebMCP: your website becomes a tool AI agents can call
WebMCP lets a site expose typed actions to AI agents instead of making them screenshot and guess. A flight demo went from 500K tokens to 1K. How it works.
You can't ship AI you can't evaluate
AI features are non-deterministic, so 'it looked right in the demo' isn't a test. Evals - a dataset plus graders, run in CI and prod - are how you ship them.
Accessibility is the law now: the EAA and your product
The European Accessibility Act is in force, yet 94.8% of top homepages fail WCAG. Here's what the law requires and the six fixes that clear most of the gap.
The cloud bill nobody modeled: egress and the IPv4 tax
Cloud providers now compete on networking, not compute. Egress, NAT, and IPv4 fees are a hidden ~18% tax - and optimization tops out where architecture wins.
INP is the metric that catches you: designing for response
INP is the most-failed Core Web Vital - 43% of sites miss it. It measures response after a tap, not load, so a fast page can still fail. Here's the fix.
Designing a backend an AI agent can actually use
Agents retry, chain, and act unsupervised - so APIs built for humans break. Idempotency, structured errors, and observability make a backend agent-ready.
On-device AI grew eyes: Apple's 2026 model framework
Apple's on-device model now takes images, calls Vision tools, and runs behind one API that swaps to Claude or Gemini - free, private, on the phone.
Repository intelligence: your codebase is the context now
AI coding moved from autocompleting lines to understanding whole repos - and running several agents on one task. Here's what changes for how teams build.
Passkeys are the default now: killing the password in 2026
Passkeys hit ~5 billion in use and a 93% login-success rate vs 63% for passwords. Here's the mechanism, the real numbers, and when to add them.
Your backend is a folder now: what Server Actions changed
For many web apps the backend is now typed functions in the frontend repo, not a separate service. The catch: every one is a public endpoint you must guard.
You can delete your useMemo: what the React Compiler does
React 19's compiler auto-memoizes at build time - 20-60% fewer re-renders with zero code changes. Here's the mechanism, and when to keep a manual hook.
The delegation gap: why AI does most of the work but runs little of it
Developers use AI in ~60% of their work but can fully delegate only 0-20% of tasks. That gap - not the hype - is what actually shapes AI-era engineering.
One agent isn't enough: when to use multiple AI agents
Multi-agent systems beat a single model by ~90% on the right tasks - and burn 15x the tokens on the wrong ones. Here's how to tell which is which.
Swift 6 concurrency: the data-race reckoning is here
Building on the iOS 26 SDK is now mandatory - but only 38% of teams have turned on Swift 6's data-race safety. That gap is where the crashes hide.
The hidden bill of AI-generated code
AI assistants ship code fast - and technical debt and leaked secrets behind it. Winning teams treat the assistant as an untrusted contributor, not a colleague.
Liquid Glass: using Apple's new iOS 26 design language well
iOS 26's Liquid Glass is the biggest visual shift since iOS 7. Reserve it for the navigation layer, and never ship it without the accessibility gates.
You don't need a frontier model: the case for small language models
Most teams pay frontier prices for work a small model does just as well. The 2026 move is right-sizing - SLM-first, escalate only the hard part.
Context engineering: the real skill behind AI agents that work
The teams whose AI features work aren't using better models - they're feeding them better context. Why context quality, not size, is the 2026 bottleneck.
React Server Components in 2026: what they actually change
RSC is now the production-standard React architecture - it ships less JavaScript and fetches data on the server. The real shift, and the pitfalls.
You probably don't need a vector database
The AI wave pushed everyone toward a dedicated vector database. For most apps, Postgres with pgvector does the job - one fewer system to run, secure, and sync.
Apple's on-device AI is now an API
The Foundation Models framework gives any iOS app a ~3B-parameter model for free - no key, no network, no per-token cost. Here's the architecture that follows.
The JavaScript you can delete in 2026
Tooltips, scroll animations, modals, page transitions - a wave of native CSS features hit Baseline and replaced the libraries. Less code, faster sites.
Your API needs an MCP server (and it's a security boundary)
AI agents are a new class of API consumer, and MCP is how they call your backend. The interesting work isn't the tools - it's auth, scoping, and audit.
AWS vs Azure vs Google Cloud in 2026: how to choose
AWS vs Azure vs Google Cloud in 2026: real market share, what each is genuinely best at, and a practical way to choose - without the hype.
Coding agents in 2026: what SWE-bench scores really mean
Coding agents went from 2% to ~94% on SWE-bench in three years. Here's what those scores really mean - and where the agents still need a human.
How to control your cloud costs in 2026 (FinOps that works)
How to control cloud costs in 2026: where the ~27% of wasted spend goes, the fixes that actually move the bill, and how FinOps cuts it 15-30%.
How AI agents remember: memory systems in 2026
How AI agents remember in 2026: the four memory types, the tiered architecture that beats a growing transcript, and when your agent actually needs memory.
How to design an API that lasts (2026)
How to design an API that survives real use: REST vs GraphQL, versioning from day one, and the backward-compatibility rules that stop you breaking clients.
Is RAG dead? RAG vs long context in 2026
What RAG is really for in 2026, when a long-context window beats it, and why naive RAG died while agentic retrieval is thriving.
Next.js vs React in 2026: which should you build with?
Next.js vs React in 2026: they're not rivals - Next.js is built on React. The real difference, the SEO gap, and when to use each.
Node.js vs NestJS in 2026: choosing your backend stack
Node.js vs NestJS in 2026: NestJS runs on Node, it's not an alternative. When raw Express is right, when NestJS earns its structure, and where Fastify fits.
SQL vs NoSQL in 2026: how to choose (start with Postgres)
SQL vs NoSQL in 2026: why Postgres is the safe default, when a document database actually wins, and how to choose without regretting it later.
What DevOps actually is (CI/CD, IaC, and the DORA metrics)
What DevOps actually is in 2026: CI/CD, infrastructure as code, and monitoring, plus the four DORA metrics that tell you whether it's working.
What an AI agent actually is (and what makes one reliable)
A plain-English anatomy of an AI agent: model, tools, memory, context, and the loop, plus applications and why most agents fail on state, not smarts.
Does your business actually need AI? A 2026 reality check
A neutral guide to when AI is worth it for your business in 2026: why most projects fail, where AI genuinely helps, and how to tell the difference.
How much does a website cost in 2026?
A neutral breakdown of website costs in 2026: DIY vs freelance vs agency, what drives the price, and the three-year total that matters more than the quote.
How to choose an app development company in 2026
A neutral, evidence-led guide to choosing an app development company: the criteria that predict success, and when a small studio isn't the right fit.
What makes a website fast: Core Web Vitals in 2026
A plain-English guide to what makes a website fast in 2026: the three Core Web Vitals Google measures, what slows sites down, and how to fix it for good.
The SEO + GEO playbook: rank in Google and get cited by AI
A step-by-step SEO and GEO playbook to rank in Google and get cited by AI search - with our own site, ashvara.io, as the worked example.
How to show up in AI search: GEO in 2026
AI Overviews now hit nearly half of all searches. Here's how Generative Engine Optimization actually works - backed by the research - and why it's SEO's next chapter, not its replacement.
What does it cost to build an app in 2026?
A straight answer with real 2026 numbers - what apps actually cost, what drives the price, and why the build is only half the bill.
Agentic AI's real challenge isn't the demo - it's production
Gartner says 40% of enterprise apps will embed AI agents by end of 2026, yet fewer than 1 in 4 teams have scaled one to production. Here's why, and how to close the gap.
On-device AI is quietly winning - and it's a gift for privacy
Over 2 billion phones now run local language models, NPUs are standard, and small models are 10–30× cheaper to run. Why the future of AI is increasingly local.
AI coding agents changed how we build - not whether craft matters
Command-line coding agents are shipping real engineering work 30% faster. What that actually changes for a software studio, and what it doesn't.
Why we ship local-first software
The network is optional. Your data isn't. How building offline-first changes everything - from the data model to the way an app feels in the hand.
Designing a scoring app you can use one-handed
What scoring a live cricket match taught us about tap targets, thumbs, and sunlight.
Keeping health data on the device
Building Lunara without servers - why some data should never leave the phone.
Pay-once, where it fits
Not everything needs a subscription. When a one-time purchase is the honest model - and when it isn't.
What "end to end" actually means
One team from first sketch to production - and why fewer handoffs ship better software.
Shipping to the App Store without the drama
A repeatable checklist for review, metadata, and release - so launch day is boring.
Native vs Cross-Platform: What Should Your Business Build?
A practical guide to choosing native or cross-platform for your app - cost, speed, and long-term fit.