Customer Success Associate

The two-person team: the domain expert prompts, the engineer connects. At RenderATL I had the same conversation twice, from two different sides. The first was at the Commit Awards with Mat Biilmann, Netlify's CEO. The second was the next day, in the expo hall, with Danny Thompson, developer advocate and one of the most grounded voices on what AI actually changes about the job. Mat is watching a new kind of builder show up: the domain expert who no longer needs an engineer to translate their idea into an app. Danny is watching engineers panic that this makes them obsolete. Both of them are right, and the interesting thing is that they're describing the same team from opposite ends. Here's the team I think is forming. The new two-person team. Picture an HR business partner who is tired of the sentiment survey tool her company pays for. She knows exactly what she wants: the questions, the cadence, how the results should roll up. What she's never had is a way to build it without filing a ticket and waiting two quarters for it to climb the engineering backlog. Now she prompts a coding agent and gets a working app. Mat tells a version of this story about a real HR partner who replaced Culture Amp with her own app, built alongside a single developer, "cutting out the product-manager-to-engineer translation loop entirely." She decides what to build. The agent handles most of how. That split is the whole story. Anthropic's Economic Index put it plainly earlier this year: "people decide what to build, and the agent decides how to build it," and the more understanding a person brings to the agent, the better the work that comes back. Non-engineers in that study landed within a few points of professional software engineers on task success. The domain expertise turns out to be the scarce part. The code was never the point. The temptation is to read this as "agents replace engineers," which is wrong. This isn't about replacing engineers. It's about the enormous queue of software that domain experts need and can't get, because it sits too far down engineering's backlog to ever ship. The internal tool that would save one team ten hours a week but doesn't clear the bar against revenue work. The one-off app for a single department, all the software that matters to somebody but never matters enough to fund, that's the queue that's about to drain. And it drains by empowering the people who feel the pain, not by firing the people who build. Where the agent stops. The agent gets you a long way, fast, and then hits a wall. Addy Osmani named this the "70% problem": non-engineers "get 70% of the way there surprisingly quickly, but that final 30% becomes an exercise in diminishing returns." The last stretch, the requirements you didn't know to state, the edge cases, the security, the performance, still needs human judgment. And notice where the wall is. The app itself, the thing the agent generates, is usually the easy part now. The wall is everything the app has to touch. Real authentication, the existing database that already holds the company's data, the internal API that speaks a format nobody documented, the third-party system with a rate limit and a login flow. Mat is blunt about this: agents "excel at generating code," but "the path from prompt to production is still filled with obstacles," and the hardest of those is working "with existing legacy code bases and data sources." This is not a cosmetic gap. The Cloud Security Alliance surveyed 5,600 vibe-coded apps and found that zero of them had CSRF protection, security headers, or properly scoped access policies. The demo runs, the wiring to the real world is missing, and when it's there, it's often wrong in ways the person who prompted it can't see. That gap has a name in a dozen different write-ups: the "70% problem," Vercel's "90% problem," the "last mile." They're all pointing at the same seam: the code generates, the connections don't. Connectivity is the job now. So what does the engineer do on the two-person team? They own the seam. Not the app, the domain expert can conjure the app. The engineer builds the connective tissue: the API that exposes the legacy system cleanly, the auth that actually holds, the integration that lets the shiny new tool read from the warehouse of record. Yoko Li at a16z put it well: "agents can generate a lot of code, but they still need something solid to plug into." The engineer builds the "something solid." Danny frames the human half of this as well as anyone. His line is that "the prompt-and-pray era is over - and that's a good thing," and that your value now is "caring, context, judgment, and composing solutions." Not typing the app into existence, but composing the systems it depends on, and having the judgment to know where it will break. He talks about the real production work as state orchestration, constraint generation, infrastructure reliability, and regression testing - none of which the agent volunteers, and all of which decide whether the thing survives contact with real users. That's a promotion, not a demotion. The engineer stops being the translator between a PM's intent and a codebase, the slow, expensive step in the middle, and becomes the person who makes the domain expert's app real. Higher leverage, less busywork, more of the work that was interesting in the first place. So how do you trust what got shipped? There's a harder question hiding under all of this, and it's the one an engineering leader should actually lose sleep over. When the person building the app can't read the code, "does it work?" stops meaning "does it compile" and starts meaning "does it do the right thing against real systems, safely, every time." Correctness moves up a level. And the place it's most likely to fail silently is exactly the seam the engineer owns: the API call that succeeds with the wrong scope, the integration that returns stale data, the auth path that lets the wrong person through. Which means the engineer's contribution isn't just building the connectivity. It's proving the connectivity behaves. Tests, evals, observability into what the app actually does in production: these stop being hygiene you get to later and become the deliverable. On a team where one person can ship something they can't fully inspect, the person who can inspect it is what keeps it trustworthy. That's not overhead. On this kind of team, it's the point. The team didn't shrink. It re-specialized. Go back to the two conversations at RenderATL. Mat is right that the translation loop is collapsing and a new cohort of builders is showing up. Danny is right that the engineer's value didn't evaporate. It moved. Put them together and you don't get a smaller team. You get a differently-shaped one: the domain expert who knows what to build and can now prompt it into being, paired with an engineer who gives that creation a nervous system, the connections to real systems, and the proof that those connections hold. For anyone staffing or leading engineering, that reframes the whole question. The goal was never to protect engineers from agents, or to replace engineers with them. It's to finally ship the mountain of software that real people needed and never got, because it lived forever at the bottom of a backlog. The domain experts can start it now. The engineers are what make it real.

Summer Summit: what I learned by getting stuck on its own product. * Home * / * Blog * / * Article August 8, 2026 Last week at its Summer Summit Buildathon, the entire Netlify company came together to build on Netlify Agent Runners. Like everyone else, I set out to build a site that would publish blogs to multiple websites. I didn't get very far. Instead, I got stuck. And that turned out to be the most valuable part of the day. I wasn't reading customer feedback. I was the customer. I experienced exactly what a new builder experiences. I wasn't reading customer feedback or watching a demo. I was the customer. I hit a step that asked me to configure a build hook and connect it to a repo. Then I got an error: "Build hook could not configure." My immediate reaction was, "What is a build hook?" One error message changed how I think about its product. That one moment changed how I think about its product. It reminded me that every confusing workflow, every unclear error message, and every assumption Richardterrylloyd make creates friction for someone trying to build. Watching its engineers, true professionals, work through these challenges also gave me a deeper appreciation for the craft that goes into building great developer tools. The lesson came from getting stuck. The biggest lesson, though, came from getting stuck myself. The executive who experiences their own product the way a first-time customer does isn't wasting time. They're getting the most honest product feedback possible. If you lead a platform company, spend time building on your own platform. You'll learn things no dashboard, customer interview, or product review can teach you. If you've had a moment like this on your own platform, I'd love to hear about it. Find me on LinkedIn.

Netlify's AI Gateway and Agent Runners now support DeepSeek, Qwen, GLM, and Kimi. Netlify's AI Gateway and Agent Runners now route to DeepSeek, Qwen, GLM, and Kimi alongside Claude and GPT. Per-model pricing isn't published yet. BuilderWithin Editorial Team BuilderWithin What happened. Netlify announced "full model freedom" across two of its production AI tools on August 6. Through partnerships with OpenRouter (a marketplace that routes requests to many different AI models through one connection) and OpenCode (a free, publicly available coding agent that can be pointed at different underlying models), Netlify now offers open-weight models alongside Claude, GPT, and Gemini. Open-weight models are AI models whose underlying files are published so anyone can run or host them, instead of being locked behind one company's paid service. DeepSeek, Qwen, GLM, and Kimi, all named in Netlify's announcement, fall into that category. This lands in two places. AI Gateway is Netlify's routing layer for AI calls inside apps you've built: it sits between your app and whichever model provider you pick, so you can change the underlying model without rewriting the code that connects your app to that provider. Agent Runners are Netlify's own in-dashboard coding agents: you open a project, describe a change, and an agent edits the code and builds a preview version of your site that you can check before it replaces the live one. Until now, Agent Runners let you choose from four engines: Claude Code, OpenAI Codex, Google Gemini, or OpenCode. The open-weight models arrive specifically through OpenCode, which you select as the agent and then point at a model like DeepSeek or Kimi K3 instead of a closed one. Why it matters. Model choice affects both what a task costs and how well it gets done, and different models are better at different kinds of work. Being able to swap the model behind an agent, or behind a live request your app sends out, without touching the connecting code, is a genuine convenience. It also means a bad day for one model provider, an outage or a sudden price change, doesn't have to become your app's bad day. The gap is pricing. Netlify's announcement doesn't publish what an open-weight model run costs compared to a Claude or GPT run. Netlify's own Agent Runners documentation confirms that runs are billed in credits, on Free, Personal, and Pro plans, covering AI inference and compute time. It does not list per-model credit costs. So "open-weight models are cheaper" is the industry's general reputation for these models, not a number Netlify has committed to for this feature. Don't assume a DeepSeek or Kimi run will cost less in credits than a Claude run until you've checked. There's also a data-handling question worth a beat of caution. Open-weight models on Netlify are hosted through the OpenRouter partnership, a third party, not run directly by Netlify or by the model's original lab. If your app handles user data you're accountable for, check OpenRouter's and the specific model's data retention policy, how long they keep the data you send and what they do with it, before pointing your app's AI Gateway traffic at a new model. The terms may differ from whatever provider you were using before. Who should care. Anyone using Netlify's Agent Runners for day-to-day code changes, and anyone using AI Gateway to route AI calls inside a deployed app who wants a cheaper or alternate model without rewriting how their app talks to its model provider. What builders should do next. In your Netlify project dashboard, open the "Build with an AI agent" section and start a new Agent Run. Choose OpenCode as the agent, then pick an open-weight model like DeepSeek or Kimi K3 from the model list, and run a small bounded task, such as fixing a failing test or adding input validation to a form. Run the identical task again with Claude Code or Codex as the agent. Compare two things: the credits each run consumed, visible in the agent run detail view, and whether the output passed the same tests without you needing to fix follow-up issues. That comparison, not the announcement itself, is what tells you whether switching is worth it for your project. End of article BuilderWithin Weekly · Free If you found this useful, subscribe free. Get BuilderWithin Weekly in your inbox. Daily briefings publish on the site, and the weekly roundup pulls together what mattered. Unsubscribe any time. BuilderWithin Weekly · Free · No spam Get BuilderWithin Weekly in your inbox. One weekly roundup in your inbox. Daily briefings publish on the site for people who ship products. Unsubscribe any time · Weekly email, always free