Field notes
Field notes on useful AI systems.
Essays on spotting the right problems, mapping the workflows behind them, and turning AI ideas into software people actually use.
From the archive
Ideas you can test against actual work.
GPT-5.6 is not just a model launch. It is a dependency warning.
OpenAI's GPT-5.6 preview shows why founders should treat frontier model releases like infrastructure changes, not novelty drops.
Export Controls Do Not Pause AI Demand. They Reroute It.
The Anthropic Mythos export-control story is really an operating lesson: if AI is part of your delivery promise, vendor dependency is product risk.
Your AI agent should fail in a fake company before it touches the real one
AI agents need simulated workflows, replayable traces, permissions, and human review before they act in production systems.
AI Can Make Your Team Faster and Weaker at the Same Time
AI can accelerate teams, especially less experienced ones, but bad adoption can remove the reps that build judgment. Operators need an AI reps policy.
Your Custom Software Needs an Exit Strategy Before It Needs More Features
Custom software becomes dangerous when nobody can change it, operate it, or leave it. The best time to design an exit strategy is before the product feels stuck.
Your AI Intake Process Is Turning Every Idea Into a Project
Most AI backlogs are not strategy. They are a pile of requests with model names attached. Here is how to qualify AI work before it wastes engineering time.
Your AI Vendor Evaluation Is Buying Demos, Not Capability
Most AI vendor evaluations reward the best demo instead of the strongest operating fit. If you want tools that survive production, test workflow depth, data readiness, integration cost, controls, and ownership before you buy.
Your AI Support Bot Needs Escalation Design, Not Better Small Talk
Most AI support bots fail because teams obsess over tone and coverage while ignoring the handoff. Reliable support automation needs clear escalation rules, ownership, and failure paths.
Your Architecture Decisions Are Expiring Without Anyone Noticing
Architecture decisions are not permanent truths. They are bets made under constraints. If nobody records why they were made, when they should be revisited, and what would invalidate them, your system slowly turns into unexplained risk.
Your AI Evaluation Plan Is Testing Demos, Not Production Risk
Most AI evaluations are built to prove a demo works, not to expose where the system will fail in production. The useful version tests risk, edge cases, drift, recovery, and business impact before users find the cracks.
Your Feature Flags Are Becoming Production Debt
Feature flags are supposed to reduce release risk. But when teams never remove them, never assign ownership, and use flags as a substitute for product decisions, they turn into another layer of production debt.
Your Product Analytics Are Measuring Noise, Not Decisions
Most teams have plenty of product data and very little product clarity. The fix is not more dashboards. It is designing analytics around decisions before you instrument the product.
Your AI Agent Needs Permission Boundaries, Not More Personality
Most AI agent projects spend too much energy on how the agent talks and not enough on what it is allowed to do. Production agents need permission boundaries, audit trails, and escalation rules before they need charm.
Your AI Workflow Needs a Data Contract, Not More Context
When AI output gets shaky, most teams stuff more context into the prompt. That usually makes the system slower, more expensive, and harder to trust. The better fix is a data contract around what goes in, what comes out, and what gets rejected.
Stop Automating Approval Chains. Start Removing Them.
A lot of automation projects focus on speeding up approvals that should not exist in the first place. If your workflow depends on too many signoffs, AI will only make the waste happen faster.
Your Fear of AI Vendor Lock-In Is Distracting You From the Real Risk
A lot of teams spend months designing for model portability before they have anything worth porting. The bigger risk is building an AI system nobody can operate, measure, or trust.
Your Operations Team Shouldn't Be Acting as Human Middleware
If work only moves because someone keeps copying information between tools, translating vague requests, and chasing approvals, you do not have a scalable operation. You have people compensating for weak systems.
Your Browser Automation Is Not an Integration Strategy
Browser automation has its place. But if your core workflow depends on clicking through someone else's UI because you skipped the data and integration design work, you are building operational debt.
Your Code Review Process Is Optimized for Politeness, Not Quality
A lot of teams say code review protects quality. In practice, their review process is built to avoid friction, clear queues, and preserve feelings. That is not the same thing.
Your AI Cost Problem Is an Architecture Problem, Not a Model Problem
When AI spend starts climbing, most teams blame the model. Usually the real issue is a sloppy architecture that creates waste, retries, and unnecessary model calls.
Your AI Governance Plan Is Blocking the Wrong Things
A lot of AI governance efforts create friction where the risk is low and stay vague where the risk is real. Good governance should speed up safe adoption, not slow everything down equally.
Your Incident Response Is Built on Heroics, Not Systems
A lot of teams say they care about reliability, then handle outages through Slack chaos and memory. If your incident response depends on a few heroes, your operating model is weaker than you think.
Your Staging Environment Is Lying to You
A lot of teams treat staging as proof that a release is safe. It usually is not. If your staging environment does not reflect real traffic, real data shape, and real operational constraints, it creates false confidence instead of reducing risk.
You Don't Need Platform Engineering. You Need Paved Roads
A lot of teams reach for platform engineering before they have the scale to justify it. Most do not need an internal platform team. They need a few opinionated defaults that remove repeatable friction.
Your RAG Project Is a Content Operations Problem, Not an AI Problem
Most retrieval-augmented generation projects fail for a boring reason: the model is not the bottleneck. Your documents, ownership, and update process are. Here's how to build RAG that survives contact with the real business.
Your AI Pilot Needs a P&L, Not a Demo
Most AI pilots fail because they are judged by novelty instead of economics. If you cannot explain the cost, margin, and operating model of the workflow, you do not have a serious AI initiative yet.
Your Developer Onboarding Is Running on Tribal Knowledge
Most teams think slow onboarding is a hiring problem. It usually is not. It is a systems problem caused by undocumented decisions, fragile handoffs, and too much knowledge trapped in a few people's heads.
Your AI Rollout Needs an Owner, Not a Steering Committee
Most AI rollouts stall because nobody owns the workflow, the outcome, or the ugly operational details. Committees create motion. Owners create adoption.
Stop Comparing AI Models. Start Measuring Task Reliability
Most AI buying decisions are still based on model demos, leaderboard scores, and vendor claims. That is backwards. The real question is whether the system can perform a business task reliably enough to trust in production.
Your Dashboard Isn't a Strategy, It's a Screenshot of Confusion
Most companies do not have a reporting problem. They have a decision problem. More dashboards usually create more noise, more meetings, and slower action.
Your AI Meeting Notes Are Creating More Noise Than Clarity
AI meeting assistants promise perfect recall and better alignment. In practice, they often create a bigger mess. Here's what businesses get wrong and how to make meeting automation genuinely useful.
Your Internal AI Chatbot Is Not a Knowledge Strategy
Companies keep building internal AI chatbots to solve knowledge chaos. Most of them just add another interface on top of bad documentation and weak ownership. Here's what actually works.
If You Can't Measure Your AI Output, You Don't Have a Product
Too many AI products ship with polished demos and zero evaluation discipline. If you cannot measure output quality, reliability, and failure modes, you do not have a real product yet.
Your Bugs Aren't a QA Problem. They're a Scope Problem
Most teams treat quality as something QA catches at the end. That is backwards. A lot of bugs are created much earlier, when scope is vague, bloated, and full of unmade decisions.
You Probably Don't Need Real-Time, You Need Reliable
A lot of teams overbuild for instant updates when the business really needs consistency, clarity, and fewer moving parts. Real-time is expensive. Reliability is usually what creates value.
Your Automation Strategy Is Too Fragile - Build for Exceptions, Not Happy Paths
Most automation projects fail because they are designed around the clean path instead of the messy reality. If your system cannot handle exceptions, it is not automation. It is a demo.
Your API-First Strategy Is Slowing You Down
API-first sounds disciplined, scalable, and enterprise-ready. For most early-stage products, it's also a great way to overcomplicate delivery. Here's when API-first helps, when it hurts, and what to do instead.
Your Discovery Phase Is Creating Risk, Not Clarity
Most software projects do not go off the rails during development. They go wrong earlier, when discovery produces vague confidence instead of hard decisions. Here's what better discovery actually looks like.
Your AI Transformation Is Failing in the Handoff Between Strategy and Operations
Most AI initiatives do not fail because the models are weak. They fail because strategy sounds ambitious, operations stay messy, and nobody designs the handoff between the two.
Your AI Product Needs an Operations Layer, Not Just a Better Prompt
Most AI products fail for the same reason: the prompt gets all the attention while the operating system around it stays half-built. Real value comes from orchestration, guardrails, routing, memory, and human escalation - not from prompt polish alone.
Your MVP Needs a Kill List, Not a Feature Roadmap
Most MVPs fail because they are not minimal, not focused, and not testing the right thing. The fix is not better prioritization. It is being ruthless about what to kill before you build.
No-Code Isn't a Product Strategy, It's a Timing Decision
Founders keep treating no-code versus custom development like an identity question. It is not. It is a timing, risk, and economics decision. Here is how to make the call without wasting six months.
Your AI Roadmap Is Backwards, Start With Workflows, Not Models
Most AI roadmaps start with model selection and end with expensive disappointment. The better approach is simpler: start with the workflow, the bottleneck, and the decision that needs to happen faster.
You Don't Need a Full-Time CTO Yet
Early-stage startups often hire a senior technical leader too early, too vaguely, or for the wrong job. Here's when you actually need a CTO, when you don't, and what to do instead.
Your Internal Tool Should Remove Work, Not Add Another Screen
Most internal tools fail because they digitise messy process instead of eliminating work. Here's how to build internal software that actually saves time, reduces errors, and gets used.
How to Scale Engineering Teams Without Killing Quality
Scaling engineering teams isn't about hiring more people. It's about structure, ownership, and predictable decision flow. Practical patterns we use at IndieStudio to grow without creating chaos.
Your AI Coding Assistant Is Making Your Team Worse
AI coding tools promise 10x productivity. For most teams, they're delivering 10x mediocre code faster. Here's why AI-assisted development is creating a new kind of technical debt - and how to use these tools without losing your engineering culture.
Your Engineering Team Doesn't Have a Velocity Problem - It Has a Decision Problem
Most teams blame slow shipping on technical debt, process overhead, or not enough engineers. The real bottleneck? Decisions that take weeks when they should take hours. Here's how to fix it.
The Integration Tax: Why Connecting Your Tools Costs More Than Building Them
Every new tool you adopt comes with a hidden bill - the cost of making it talk to everything else. Most teams underestimate this by 10x. Here's how to stop paying more for the glue than the product.
Your SaaS Stack Is a Liability, Not an Asset
You're paying for 47 tools and none of them talk to each other. SaaS sprawl is silently killing your productivity, your budget, and your ability to move fast. Here's how to fix it.
Your AI Proof of Concept Will Never Make It to Production
That impressive AI demo your team built in two weeks? It's going to take six months to make it production-ready. Most companies never bridge that gap. Here's why the POC-to-production chasm kills more AI projects than bad models ever will.
Microservices Won't Save Your Startup
Everyone's splitting their app into microservices because Netflix did it. But you're not Netflix, and that architecture decision is probably costing you more than it's saving. Here's when a monolith is the smarter choice.
Your Software Estimates Are a Lie (And Everyone Knows It)
Software estimation is broken. Not because developers are bad at it, but because the entire framing is wrong. Here's how to stop pretending and start planning honestly.
AI Agents Are Not Your Autonomous Workforce
Everyone's talking about AI agents replacing teams. The reality is messier. Here's what AI agents are actually good at, where they fall apart, and how to deploy them without wasting six months.
The Rewrite Trap: Why Starting From Scratch Almost Never Works
Your legacy codebase is painful. The temptation to rewrite it from scratch is real. But rewrites fail far more often than they succeed - and the reasons are predictable.
Your Data Strategy Matters More Than Your AI Strategy
Everyone's racing to build an AI strategy. Almost nobody has a data strategy worth anything. That's why most AI projects stall before they deliver real value.
Outsourcing Software Is a Trap (Unless You Do It Right)
Most companies outsource software development to save money. Most of them end up spending more than if they'd built in-house. Here's why outsourcing fails - and the model that actually works.
Your Company Isn't Ready for AI (And It's Not a Technology Problem)
Everyone wants to 'implement AI.' Almost nobody has the foundations in place to make it work. The bottleneck isn't the model - it's your data, your processes, and your expectations.
The Build vs Buy Decision Is Costing You More Than You Think
Every growing company faces the build vs buy dilemma. Most get it wrong - not because they pick the wrong option, but because they evaluate it with the wrong framework. Here's how to stop bleeding money on the wrong side of the trade-off.
Developer Productivity Is Not About Tools
Every year there's a new IDE, a new AI coding assistant, a new workflow tool that promises 10x productivity. Most of them miss the point entirely. Here's what actually moves the needle.
Remote Teams Don't Need More Meetings — They Need Better Systems
Most remote teams are just office teams on Zoom. The ones that actually work have replaced synchronous rituals with systems that scale. Here's how.
Stop Building AI Features Nobody Asked For
Every product roadmap now has an 'AI' section. Most of it is theatre. Here's how to build AI features that actually solve problems instead of just checking a box.
Technical Debt Is a Choice, Not an Accident
Everyone talks about technical debt like it's weather - something that just happens. It's not. It's the result of specific decisions, and most teams are making those decisions wrong.
Your Tech Stack Doesn't Matter (Until It Does)
Teams waste weeks debating frameworks before writing a single line of code. Most tech stack decisions don't matter early on - but a few will quietly destroy you later. Here's how to tell the difference.
Stop Hiring Engineers. Start Building Systems.
Your engineering team feels understaffed. The instinct is to hire. But most scaling problems aren't people problems - they're systems problems. Here's how to tell the difference.
No-Code Won't Save You (But It Might Buy You Time)
No-code tools are everywhere. They're genuinely useful - until they're not. Here's how to know when to use them, when to ditch them, and how to avoid the trap in between.
The MVP Trap: Why Your Minimum Viable Product Isn't
Most MVPs are either too minimal to learn anything or too built-out to call minimum. Here's how to find the sweet spot that actually validates your idea.
Why Most AI Automations Fail (And What to Do Instead)
Companies rush to automate everything with AI. Most of those projects quietly die within months. Here's the pattern we see - and the approach that actually works.