<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">
  <url>
    <loc>https://reveneau.com/insights/adding-eval-tests-was-our-best-decision</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-adding-eval-tests-was-our-best-decision.webp</image:loc>
      <image:title>Adding eval tests was the best decision we made</image:title>
      <image:caption>We generate every line of code we ship. The single change that made that safe was writing the check before the code, and it turned out to change how we review, how we spec, and how fast we can move.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/agentic-ai-framework-design</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-agentic-ai-framework-design.webp</image:loc>
      <image:title>Agentic AI framework design: how to architect a system that acts, not just answers</image:title>
      <image:caption>An agent is not a chatbot with extra steps. It is a system that plans, calls tools, and acts across multiple turns, and every one of those turns is a place it can go wrong.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/ai-agent-development-company</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-ai-agent-development-company.webp</image:loc>
      <image:title>How to choose an AI agent development company</image:title>
      <image:caption>Anyone can wire a model to a few tools and call it an agent. Here is what actually separates an AI agent development company from a team that will hand you a demo and disappear.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/ai-copilots-for-engineering-teams</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-ai-copilots-for-engineering-teams.webp</image:loc>
      <image:title>What AI coding assistants actually change on an engineering team</image:title>
      <image:caption>AI coding assistants speed up real work, but not the work that matters most. Here is what they help with, what they do not, and how to adopt them without lowering the bar.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/ai-demo-vs-the-last-mile</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-ai-demo-vs-the-last-mile.webp</image:loc>
      <image:title>An AI demo is not a product</image:title>
      <image:caption>A convincing AI demo takes an afternoon. Turning it into something people trust in production is where most of the work, and most of the failures, live.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/ai-evaluation-and-guardrails-for-production</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-ai-evaluation-and-guardrails-for-production.webp</image:loc>
      <image:title>AI evaluation and guardrails for production: how to know your AI actually works</image:title>
      <image:caption>&quot;It seems to work&quot; is not a production standard. Here is how we turn that feeling into a number, and how we stop the system from doing damage on the days the number is bad.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/ai-is-an-amplifier-not-a-fix</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-ai-is-an-amplifier-not-a-fix.webp</image:loc>
      <image:title>AI is an amplifier, not a fix</image:title>
      <image:caption>The 2025 DORA data says AI raises throughput and hurts stability at the same time. Which of those two you get is decided by what has to pass before a change ships, and by nothing else.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/ai-prototype-in-weeks</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-ai-prototype-in-weeks.webp</image:loc>
      <image:title>How to get a working AI prototype in weeks, not quarters</image:title>
      <image:caption>Most AI ideas die in the planning stage. Here is how to get something real in front of users fast enough to know if the idea is worth the full build.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/build-vs-buy-custom-software</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-build-vs-buy-custom-software.webp</image:loc>
      <image:title>Build vs buy: when custom software is actually worth it</image:title>
      <image:caption>We build custom software for a living, and we still tell most people to buy the tool. Here is how to know when building is worth it and when it is a slow mistake.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/can-you-trust-an-ai-agent</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-can-you-trust-an-ai-agent.webp</image:loc>
      <image:title>Can you trust an AI agent with real work yet?</image:title>
      <image:caption>An agent that answers a question and an agent that takes an action are not the same risk. Here is how we decide where an agent is ready to act, and where it is not.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/custom-software-development-cost</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-custom-software-development-cost.webp</image:loc>
      <image:title>What custom software actually costs when the code is nearly free</image:title>
      <image:caption>Software used to be priced by how much of it there was. That was never a great proxy and it is now a bad one. The cost of a build has moved onto two things: how clearly you can say what you want, and how hard it is to prove you got it.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/execution-speed-is-the-moat</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-execution-speed-is-the-moat.webp</image:loc>
      <image:title>Speed of execution is the moat now</image:title>
      <image:caption>Being first used to be a defensible lead. When any capable team can build the same thing in a week, the advantage moves to how fast you ship, learn, and ship again.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/five-ways-to-hire-the-right-product-manager</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-five-ways-to-hire-the-right-product-manager.webp</image:loc>
      <image:title>Five ways to hire the right product manager</image:title>
      <image:caption>The right product manager changes the trajectory of a team. The wrong one quietly slows everything down.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/fractional-cto-vs-software-development-agency</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-fractional-cto-vs-software-development-agency.webp</image:loc>
      <image:title>Fractional CTO vs. software development agency: which do you need?</image:title>
      <image:caption>One owns your technical decisions. The other builds what you already decided. Most founders need to know which problem they actually have before they hire either.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-autonomous-are-ai-coding-agents-really</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-autonomous-are-ai-coding-agents-really.webp</image:loc>
      <image:title>How autonomous are AI coding agents, really?</image:title>
      <image:caption>Engineers at the frontier labs now say a model writes one hundred percent of their code. Read the quotes closely and the human is still in every one of them. Here is what the 2026 evidence supports, and what it does not.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-many-tests-does-ai-generated-code-need</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-many-tests-does-ai-generated-code-need.webp</image:loc>
      <image:title>How many tests does AI-generated code need?</image:title>
      <image:caption>The honest answer is not a number, and coverage percentages are the wrong unit. Here is the unit we use instead, and why a suite of fifteen checks can be worth more than two thousand.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-budget-for-ai-coding-tools</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-budget-for-ai-coding-tools.webp</image:loc>
      <image:title>How to budget for AI coding tools without guessing</image:title>
      <image:caption>Seat licences are the small number. The real budget line is the review capacity you need to absorb what the tools produce, and almost nobody puts that on the spreadsheet.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-build-mobile-apps-in-a-dynamic-environment</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-build-mobile-apps-in-a-dynamic-environment.webp</image:loc>
      <image:title>How to build mobile apps in today's dynamic environment</image:title>
      <image:caption>Mobile engineering has its own set of moving parts: feature flags, release cycles, and performance budgets that shift as your app grows.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-choose-a-tech-stack-for-a-startup</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-choose-a-tech-stack-for-a-startup.webp</image:loc>
      <image:title>How to choose a tech stack for a startup without shooting yourself in the foot</image:title>
      <image:caption>Most startups pick their stack for the wrong reasons. Boring and proven beats new and exciting almost every time. Here is how to choose for speed and hiring, not for a resume.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-choose-an-ai-development-company</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-choose-an-ai-development-company.webp</image:loc>
      <image:title>How to choose an AI development company</image:title>
      <image:caption>Almost anyone can wire up an API call and show you a working demo. The company worth hiring is the one that can tell you, in plain terms, what happens when the model is wrong.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-choose-the-right-external-development-team</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-choose-the-right-external-development-team.webp</image:loc>
      <image:title>How to choose the right external development team</image:title>
      <image:caption>Hiring an outside team is a high-stakes decision. The wrong partner costs you time and momentum you cannot get back.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-choose-what-not-to-automate</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-choose-what-not-to-automate.webp</image:loc>
      <image:title>How to choose what not to automate</image:title>
      <image:caption>Most automation decisions are made by asking whether a task can be automated. That question has been answered yes for almost everything, which means it has stopped being useful.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-decide-if-a-feature-needs-a-human-in-the-loop</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-decide-if-a-feature-needs-a-human-in-the-loop.webp</image:loc>
      <image:title>How to decide if a feature needs a human in the loop</image:title>
      <image:caption>Most teams answer this by feel, then discover the rule in an incident review. Four questions decide it properly, and only one of them is about accuracy.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-decommission-a-feature-safely</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-decommission-a-feature-safely.webp</image:loc>
      <image:title>How to decommission a feature safely</image:title>
      <image:caption>Removal is the only thing that actually reduces maintenance load, and it is the only engineering work nobody ever schedules. Here is how to find what is dead, spot the dependencies you cannot see, and take it out in steps you can reverse.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-do-a-security-review-before-launch</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-do-a-security-review-before-launch.webp</image:loc>
      <image:title>A practical pre-launch security review for a small team</image:title>
      <image:caption>You do not need perfect security to launch. You need to check the handful of basics that catch most real problems, and to know when the risk is big enough to bring in a specialist.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-estimate-a-software-project</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-estimate-a-software-project.webp</image:loc>
      <image:title>How to estimate a software project honestly</image:title>
      <image:caption>A single-number estimate on new work is a promise nobody can keep. The honest version is a range that reflects real uncertainty, and the biggest driver of a bad estimate is risk nobody scoped.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-evaluate-an-ai-feature-idea</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-evaluate-an-ai-feature-idea.webp</image:loc>
      <image:title>How to tell if an AI feature idea is worth building</image:title>
      <image:caption>Most AI feature ideas demo well and die in the last mile. Here are the four questions we ask to tell the ones worth building from the ones that just look good on stage.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-handle-a-failed-software-project</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-handle-a-failed-software-project.webp</image:loc>
      <image:title>How to handle a software project that has failed</image:title>
      <image:caption>A failing software project is common, not rare. What separates a costly loss from a cheap lesson is how honestly you run the post-mortem and how clearly you decide to fix, restart, or stop.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-handle-a-security-finding-in-generated-code</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-handle-a-security-finding-in-generated-code.webp</image:loc>
      <image:title>How to handle a security finding in generated code</image:title>
      <image:caption>A scanner flags something in code no human wrote. The first instinct is to fix that line, and that is the one response almost guaranteed to leave the same defect in nine other places.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-interview-an-engineer-in-the-age-of-ai</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-interview-an-engineer-in-the-age-of-ai.webp</image:loc>
      <image:title>How to interview an engineer in the age of AI</image:title>
      <image:caption>The take-home and the whiteboard both stopped working, and for the same reason. What is left worth testing is judgment: debugging code you did not write, finding what a spec leaves out, and deciding what not to build.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-keep-a-spec-alive-after-the-build</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-keep-a-spec-alive-after-the-build.webp</image:loc>
      <image:title>How to keep a spec alive after the build</image:title>
      <image:caption>Every spec is accurate on the day it ships and wrong within a quarter. The fix is not discipline. It is making the spec something the build cannot quietly disagree with.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-launch-a-product-with-minimal-resources</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-launch-a-product-with-minimal-resources.webp</image:loc>
      <image:title>How to launch a product with minimal resources</image:title>
      <image:caption>A tight budget forces good decisions. It makes you focus on the value that actually matters and cut everything that does not.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-manage-an-external-development-team</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-manage-an-external-development-team.webp</image:loc>
      <image:title>How to manage an external development team so it feels like your own</image:title>
      <image:caption>Managing an outside team goes wrong when you count hours instead of outcomes. Here is how to steer a team that ships, instead of babysitting one that stalls.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-measure-whether-ai-is-actually-helping</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-measure-whether-ai-is-actually-helping.webp</image:loc>
      <image:title>How to measure whether AI is actually helping</image:title>
      <image:caption>Developers in one study were 19 percent slower with AI tools and believed they had been 20 percent faster. That gap is the reason you cannot run this programme on how it feels.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-negotiate-a-software-contract-you-can-verify</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-negotiate-a-software-contract-you-can-verify.webp</image:loc>
      <image:title>How to negotiate a software contract you can actually verify</image:title>
      <image:caption>Most build contracts describe effort, timeline, and payment, and leave the one hard question unanswered: on what evidence do you agree the thing is finished?</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-onboard-engineers-fast</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-onboard-engineers-fast.webp</image:loc>
      <image:title>How to onboard engineers fast so they ship in week one</image:title>
      <image:caption>Slow onboarding is a hidden tax you pay on every hire. Here is how to get a new engineer shipping real work in their first week instead of their first month.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-plan-a-migration-you-cannot-pause</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-plan-a-migration-you-cannot-pause.webp</image:loc>
      <image:title>How to plan a migration you cannot pause</image:title>
      <image:caption>The big-bang cutover is popular because it is easy to describe and easy to schedule. It is also the version where you find out whether it worked at the moment you can least afford to be wrong.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-prepare-for-technical-due-diligence</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-prepare-for-technical-due-diligence.webp</image:loc>
      <image:title>How to prepare for technical due diligence before a raise or sale</image:title>
      <image:caption>Technical due diligence is where a deal can quietly fall apart. Here is what investors' technical reviewers actually look at, how to get ahead of it, and the red flags that scare them.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-price-a-saas-product</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-price-a-saas-product.webp</image:loc>
      <image:title>How to price a SaaS product without overthinking it</image:title>
      <image:caption>Most founders price their software from their own costs, then set the number too low and never touch it again. Price on the value the customer gets, start higher than feels comfortable, and treat pricing as a lever you keep pulling.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-run-a-postmortem-when-ai-wrote-the-code</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-run-a-postmortem-when-ai-wrote-the-code.webp</image:loc>
      <image:title>How to run a postmortem when AI wrote the code</image:title>
      <image:caption>The incident review reaches the line that caused the outage, and the answer to &quot;why is it like that&quot; is that a model produced it and a person approved it in four minutes. Most postmortem formats have nowhere to put that.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-run-a-product-discovery-sprint</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-run-a-product-discovery-sprint.webp</image:loc>
      <image:title>How to run a product discovery sprint before you build</image:title>
      <image:caption>Before you commit months to building, spend a week removing your biggest unknown cheaply. Define the question, prototype the risky part, test it with real users, then decide.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-say-no-to-a-feature-request</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-say-no-to-a-feature-request.webp</image:loc>
      <image:title>How to say no to a feature request</image:title>
      <image:caption>When building got cheap, the reason to decline stopped being cost. It is now that every feature you keep makes every future change slower, and nobody sends an invoice for that.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-set-engineering-okrs</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-set-engineering-okrs.webp</image:loc>
      <image:title>How to set engineering OKRs that measure outcomes, not activity</image:title>
      <image:caption>&quot;Ship five features this quarter&quot; is a to-do list, not a goal. Good engineering OKRs measure whether users and the business are better off, which is a much harder and more useful thing to write down.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-size-a-team-when-generation-is-cheap</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-size-a-team-when-generation-is-cheap.webp</image:loc>
      <image:title>How to size a team when generation is cheap</image:title>
      <image:caption>Headcount planning still assumes writing code is the expensive part. It is not anymore, and that changes which roles are actually scarce and how many people a project can absorb before it slows down.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-take-over-a-codebase-you-did-not-write</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-take-over-a-codebase-you-did-not-write.webp</image:loc>
      <image:title>How to take over a codebase you did not write</image:title>
      <image:caption>Someone hands you a working system and leaves. The instinct is to read it. The better first move is to find out what it guarantees, because the code will tell you what it does and never what it was supposed to do.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-test-a-feature-you-cannot-fully-specify</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-test-a-feature-you-cannot-fully-specify.webp</image:loc>
      <image:title>How to test a feature you cannot fully specify</image:title>
      <image:caption>Some features have no single correct output. A summary, a ranking, a suggested reply. You cannot assert equality on those, and the usual conclusion, that they cannot be tested, is wrong.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-unlock-the-extraordinary-productivity-of-remote-work</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-unlock-the-extraordinary-productivity-of-remote-work.webp</image:loc>
      <image:title>How to unlock the extraordinary productivity of remote work</image:title>
      <image:caption>Remote work can be a productivity advantage, but only with the right habits and management approach behind it.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-write-a-bug-report-an-agent-can-act-on</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-write-a-bug-report-an-agent-can-act-on.webp</image:loc>
      <image:title>How to write a bug report an agent can act on</image:title>
      <image:caption>A bug report written for a colleague leans on everything that colleague already knows. Hand the same three lines to an agent and it will fix something, confidently, that nobody asked it to touch.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-write-a-software-development-rfp</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-write-a-software-development-rfp.webp</image:loc>
      <image:title>How to write a software development RFP that gets honest bids</image:title>
      <image:caption>Most software RFPs ask for a fixed price on a problem nobody has scoped yet, so the bids come back either padded or dishonest. Here is how to write one that gets real answers.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/how-to-write-an-acceptance-test-a-machine-can-run</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-how-to-write-an-acceptance-test-a-machine-can-run.webp</image:loc>
      <image:title>How to write an acceptance test a machine can run</image:title>
      <image:caption>Most acceptance criteria are written for a human reader who will fill in the gaps. A machine fills in nothing. Here is how to write the sentence so an automated check can enforce it.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/in-house-vs-outsourced-engineering</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-in-house-vs-outsourced-engineering.webp</image:loc>
      <image:title>In-house vs outsourced engineering: what to keep and what to hand off</image:title>
      <image:caption>The real question is not whether to build in-house or outsource. It is which parts belong to your own team forever, and which parts an outside team can do faster and better right now.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/knowing-what-to-build</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-knowing-what-to-build.webp</image:loc>
      <image:title>Knowing what to build is now the highest-leverage decision</image:title>
      <image:caption>AI made writing software cheap. That moved the hard part upstream, to deciding what deserves to be built and having the discipline to cut the rest.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/llm-integration-for-existing-products</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-llm-integration-for-existing-products.webp</image:loc>
      <image:title>How to add LLM integration to an existing product without breaking it</image:title>
      <image:caption>Most teams do not need a ground-up AI rebuild. They need one strong feature, added in a way that cannot take the rest of the product down with it.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/measure-engineers-by-outcomes-not-output</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-measure-engineers-by-outcomes-not-output.webp</image:loc>
      <image:title>You cannot measure engineers by how much they produce</image:title>
      <image:caption>Lines of code, tickets closed, and hours logged all measure motion, not progress. Here is how we think about engineering output without the vanity metrics.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/migrating-an-app-from-aws-to-gcp</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-migrating-an-app-from-aws-to-gcp.webp</image:loc>
      <image:title>Migrating an app from AWS to GCP</image:title>
      <image:caption>A cloud migration is rarely just a lift and shift. The decision touches cost, reliability, and the day-to-day experience of your engineers.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/mobile-web-or-native-how-to-decide</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-mobile-web-or-native-how-to-decide.webp</image:loc>
      <image:title>Mobile web, native, or cross-platform: how to decide</image:title>
      <image:caption>Mobile web, native, or cross-platform is a real decision with real trade-offs. But &quot;we need an app&quot; is often the wrong place to start. Here is how to decide honestly.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/monolith-vs-microservices-for-early-stage</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-monolith-vs-microservices-for-early-stage.webp</image:loc>
      <image:title>Monolith vs microservices for an early-stage startup</image:title>
      <image:caption>For almost every early-stage startup, one well-built monolith is the right first choice. Microservices solve problems you do not have yet, and they add cost you cannot afford to pay early.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/move-fast-without-breaking-the-product</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-move-fast-without-breaking-the-product.webp</image:loc>
      <image:title>How to move fast without breaking the product</image:title>
      <image:caption>Speed and quality are usually framed as a trade-off. In practice, the teams that move fastest for long are the ones that made quality cheap to keep.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/never-let-the-model-grade-its-own-work</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-never-let-the-model-grade-its-own-work.webp</image:loc>
      <image:title>Never let the model grade its own work</image:title>
      <image:caption>When the same run writes the code and the tests, a green build proves the code agrees with itself. That is not verification, and it is the most common way an AI-built codebase becomes confidently wrong.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/offshore-vs-nearshore-vs-onshore-development</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-offshore-vs-nearshore-vs-onshore-development.webp</image:loc>
      <image:title>Offshore vs nearshore vs onshore: why the cheapest hourly rate costs the most</image:title>
      <image:caption>People pick a development team by hourly rate and location, then wonder why the cheap option cost the most. What actually drives the outcome is seniority, communication, time-zone overlap, and ownership.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/procurement-for-ai-built-software</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-procurement-for-ai-built-software.webp</image:loc>
      <image:title>Procurement for AI-built software</image:title>
      <image:caption>Standard software contracts were written for an era when a person typed every line. Six clauses need rewriting when a machine writes most of them, and one of them is about who owns the output.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/rag-enterprise-search-development</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-rag-enterprise-search-development.webp</image:loc>
      <image:title>RAG enterprise search development: what it actually takes to build</image:title>
      <image:caption>A model that can search your company's own documents sounds simple until you build one. Here is the real engineering work behind RAG, and how to tell if it is actually working.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/rag-vs-fine-tuning-for-product-teams</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-rag-vs-fine-tuning-for-product-teams.webp</image:loc>
      <image:title>RAG vs fine-tuning, explained for product teams</image:title>
      <image:caption>RAG and fine-tuning sound like a deep ML choice, but the decision is simpler than it looks. Here is what each is good for, and why retrieval is almost always the right first move.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/red-flags-when-hiring-a-software-development-agency</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-red-flags-when-hiring-a-software-development-agency.webp</image:loc>
      <image:title>Red flags when hiring a software development agency</image:title>
      <image:caption>The wrong agency costs you months, not just money. Here are the warning signs worth checking before you sign a contract, not after.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/signs-your-software-project-is-in-trouble</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-signs-your-software-project-is-in-trouble.webp</image:loc>
      <image:title>The early warning signs your software project is in trouble</image:title>
      <image:caption>A software project rarely fails in one dramatic moment. It slips quietly, and the early signs are easy to explain away. Here are the ones to watch and what to do about each before it is too late.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/small-senior-team-outbuilds-a-big-one</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-small-senior-team-outbuilds-a-big-one.webp</image:loc>
      <image:title>Why a small senior team now outbuilds a big one</image:title>
      <image:caption>Adding people used to be how you went faster. With modern tools, a small team of senior engineers often ships more, and cleaner, than a large mixed one.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/software-consulting-firm-vs-development-agency</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-software-consulting-firm-vs-development-agency.webp</image:loc>
      <image:title>Software consulting firm vs. development agency: what's the actual difference?</image:title>
      <image:caption>A consulting firm sells you a recommendation. A development agency sells you working software. Confusing the two costs you a quarter you did not plan to lose.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/software-development-agency-vs-freelance-marketplace</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-software-development-agency-vs-freelance-marketplace.webp</image:loc>
      <image:title>Development agency vs. freelance marketplace: what you are actually buying</image:title>
      <image:caption>A curated freelance marketplace sells you access to individual people. An agency sells you a team that is accountable for the outcome. They solve different problems, and picking on price alone gets the difference backwards.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/software-development-partner-vs-vendor</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-software-development-partner-vs-vendor.webp</image:loc>
      <image:title>Software development partner vs. vendor: what is the real difference?</image:title>
      <image:caption>A vendor builds what you ask for. A partner tells you when what you asked for is wrong. The difference shows up months after the contract is signed.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/staff-augmentation-vs-managed-team</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-staff-augmentation-vs-managed-team.webp</image:loc>
      <image:title>Staff augmentation vs a managed team that owns the outcome</image:title>
      <image:caption>Adding individual engineers to your team and hiring a team that owns an outcome look similar on an invoice. They are not the same thing, and picking the wrong one hides a large management cost you did not budget for.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/stop-paying-for-headcount</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-stop-paying-for-headcount.webp</image:loc>
      <image:title>Stop paying for headcount you no longer need</image:title>
      <image:caption>An hourly quote is a price for people and months. When most of the implementation is generated, that is a price for an input that has largely gone, and it quietly pays your supplier to be slow.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/technical-due-diligence-for-vc-portfolio-companies</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-technical-due-diligence-for-vc-portfolio-companies.webp</image:loc>
      <image:title>Technical due diligence for VC portfolio companies</image:title>
      <image:caption>Before you commit capital, you need a clear read on the code, the team, and the risk behind it. Here is what a real technical due diligence review covers.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/the-cost-of-a-dependency-you-did-not-choose</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-the-cost-of-a-dependency-you-did-not-choose.webp</image:loc>
      <image:title>The cost of a dependency you did not choose</image:title>
      <image:caption>A coding agent adds a package in four seconds and the decision is never discussed. Someone owns that package for the next five years, and it will not be the agent.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/the-eu-ai-act-deadline-that-moved</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-the-eu-ai-act-deadline-that-moved.webp</image:loc>
      <image:title>The EU AI Act deadline that moved, and what to do with the time</image:title>
      <image:caption>Teams spent two years planning around August 2026. The high-risk obligations were deferred shortly before it arrived. The useful response is to notice which parts of the plan were only ever about the date.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/the-questions-to-ask-before-approving-an-ai-build</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-the-questions-to-ask-before-approving-an-ai-build.webp</image:loc>
      <image:title>The questions to ask before approving an AI build</image:title>
      <image:caption>You are being asked to sign off on a build where most of the code will be generated. You do not need to read the code. You need nine questions and the confidence to keep asking until you get a specific answer.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/the-real-cost-of-shipping-unverified-code</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-the-real-cost-of-shipping-unverified-code.webp</image:loc>
      <image:title>The real cost of shipping unverified code</image:title>
      <image:caption>The invoice for unverified code does not arrive as a bug report. It arrives as a codebase nobody will touch, a review queue that never clears, and a team that has stopped trusting its own pipeline.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/the-review-queue-is-the-new-bottleneck</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-the-review-queue-is-the-new-bottleneck.webp</image:loc>
      <image:title>The review queue is the new bottleneck</image:title>
      <image:caption>When code got faster to write, the constraint moved to the one place nobody measures. A review queue is invisible for about a quarter, and by the time you can see it the fastest-moving work is also the least read.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-a-good-handover-document-contains</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-a-good-handover-document-contains.webp</image:loc>
      <image:title>What a good handover document actually contains</image:title>
      <image:caption>Most handover documents describe the architecture, which is the one thing the next team can work out for themselves. The valuable parts are the decisions, the unknowns, and the things only one person knew.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-a-good-technical-spec-looks-like</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-a-good-technical-spec-looks-like.webp</image:loc>
      <image:title>What a good technical spec looks like when a model writes the code</image:title>
      <image:caption>The old advice was to keep specs short and stop where writing the code is faster. That advice assumed a person was reading it. When a model writes the code, the cost of an unanswered question moves, and so does the right length of a spec.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-a-rollback-plan-looks-like-for-ai-written-features</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-a-rollback-plan-looks-like-for-ai-written-features.webp</image:loc>
      <image:title>What a rollback plan looks like for AI-written features</image:title>
      <image:caption>Reverting the commit is the easy half. The half that ruins a Friday is the data the feature already wrote, and nobody plans for that until they have to.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-an-ai-native-team-actually-looks-like</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-an-ai-native-team-actually-looks-like.webp</image:loc>
      <image:title>What an AI-native team actually looks like</image:title>
      <image:caption>An AI-native team is not a normal team with a licence for a coding assistant. The roles shift, the review queue moves, and the job that grows is the one nobody has a title for yet.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-belongs-in-a-runbook-nobody-reads</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-belongs-in-a-runbook-nobody-reads.webp</image:loc>
      <image:title>What belongs in a runbook nobody reads</image:title>
      <image:caption>Most runbooks are written for a calm reader who has time. The person who opens one is tired, frightened, and has about ninety seconds, and almost nothing in a normal runbook survives that.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-changes-when-your-junior-engineers-use-agents</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-changes-when-your-junior-engineers-use-agents.webp</image:loc>
      <image:title>What changes when your junior engineers use agents</image:title>
      <image:caption>The path to senior ran through writing a lot of code and having it picked apart. If the agent writes it, that loop stops running, and nobody notices for about eighteen months.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-founders-get-wrong-about-ai-agents</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-founders-get-wrong-about-ai-agents.webp</image:loc>
      <image:title>What founders get wrong about AI agents</image:title>
      <image:caption>A slick agent demo and a reliable agent are two very different things. Most of the work, and most of the risk, lives in the last mile nobody shows in the demo.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-good-code-review-looks-like</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-good-code-review-looks-like.webp</image:loc>
      <image:title>What good code review looks like when nobody wrote the code</image:title>
      <image:caption>With human code, the author is the first line of defence and review is the second. With generated code, review is the only line. That one change rewrites most of what a reviewer should be doing.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-is-technical-debt-and-when-to-pay-it</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-is-technical-debt-and-when-to-pay-it.webp</image:loc>
      <image:title>What technical debt really is, and when to pay it back</image:title>
      <image:caption>Technical debt is not messy code. It is a deliberate trade of quality for speed. Here is how to tell smart debt from reckless debt, and when to pay each one back.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-to-do-when-the-ai-writes-the-wrong-abstraction</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-to-do-when-the-ai-writes-the-wrong-abstraction.webp</image:loc>
      <image:title>What to do when the AI writes the wrong abstraction</image:title>
      <image:caption>A wrong abstraction does not fail a test or break a build. It quietly makes the next twenty changes harder, and by the time anyone notices, the cost of removing it has grown into a project.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-to-do-with-the-code-nobody-understands</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-to-do-with-the-code-nobody-understands.webp</image:loc>
      <image:title>What to do with the code nobody understands</image:title>
      <image:caption>Every system has a part everyone avoids. The instinct is to rewrite it or ignore it, and both are wrong for the same reason: you cannot tell yet which of its behaviour is deliberate.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/what-to-look-for-in-a-cto-hire</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-what-to-look-for-in-a-cto-hire.webp</image:loc>
      <image:title>What to look for in a CTO hire, especially your first</image:title>
      <image:caption>Your best engineer is not automatically your best CTO. Here is what a technical leader actually needs, and how to decide between a fractional and a full-time hire.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/when-speed-is-the-wrong-goal</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-when-speed-is-the-wrong-goal.webp</image:loc>
      <image:title>When speed is the wrong goal</image:title>
      <image:caption>We sell speed. It is still the wrong target on four kinds of work, and knowing which four is worth more than another week shaved off a timeline.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/when-to-rewrite-vs-refactor-legacy-code</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-when-to-rewrite-vs-refactor-legacy-code.webp</image:loc>
      <image:title>When to rewrite vs refactor legacy code (and why the big rewrite is usually wrong)</image:title>
      <image:caption>The full rewrite feels clean and honest, and it is almost always the wrong instinct. Here is when a rewrite is genuinely justified and how to replace old code piece by piece instead.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/who-signs-off-on-ai-written-code</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-who-signs-off-on-ai-written-code.webp</image:loc>
      <image:title>Who signs off on AI-written code?</image:title>
      <image:caption>A test can only enforce a rule somebody already thought of. When AI writes most of the code, the question that decides whether a codebase stays trustworthy is who is accountable for the rule that was missing.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/why-ai-generated-code-fails-code-review</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-why-ai-generated-code-fails-code-review.webp</image:loc>
      <image:title>Why AI-generated code fails code review in a different way</image:title>
      <image:caption>Hand-written code fails review because it looks wrong. Generated code fails because it looks right, and human review is a process tuned to catch the first kind.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/why-choose-a-startup-over-a-corporate-job</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-why-choose-a-startup-over-a-corporate-job.webp</image:loc>
      <image:title>Why choose a startup over a corporate job</image:title>
      <image:caption>Startups and large companies offer very different kinds of growth. One gives you range and ownership early; the other gives you structure and scale.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/why-flaky-tests-are-worse-when-agents-write-them</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-why-flaky-tests-are-worse-when-agents-write-them.webp</image:loc>
      <image:title>Why flaky tests are worse when agents write them</image:title>
      <image:caption>A flaky test used to cost a rerun and some irritation. When an agent is reading the result to decide whether it is finished, an unreliable check becomes an unreliable instruction.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/why-observability-matters-more-with-generated-code</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-why-observability-matters-more-with-generated-code.webp</image:loc>
      <image:title>Why observability matters more when a machine wrote the code</image:title>
      <image:caption>When a person writes a system, someone carries a mental model of it. When a model writes it, nobody does, and production becomes the only place the truth still lives.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/why-permissions-are-the-hardest-part-of-an-ai-feature</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-why-permissions-are-the-hardest-part-of-an-ai-feature.webp</image:loc>
      <image:title>Why permissions are the hardest part of an AI feature</image:title>
      <image:caption>A normal feature shows one user one screen. An AI feature reads across everything it can reach and writes a summary, and a summary has no permission model.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/why-scope-creep-happens-and-how-to-stop-it</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-why-scope-creep-happens-and-how-to-stop-it.webp</image:loc>
      <image:title>Why scope creep happens and how to stop it</image:title>
      <image:caption>Scope creep is rarely about laziness or bad discipline. It is about unclear goals and a fear of saying no. Here is how to keep scope honest without killing good ideas.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/why-the-second-ai-project-is-harder-than-the-first</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-why-the-second-ai-project-is-harder-than-the-first.webp</image:loc>
      <image:title>Why the second AI project is harder than the first</image:title>
      <image:caption>The first one had no users, no legacy data, and no opinions to satisfy. The second one meets all three at once, and the team reads the slowdown as their own failure rather than a change in the problem.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/why-your-mvp-should-do-less</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-why-your-mvp-should-do-less.webp</image:loc>
      <image:title>Why your MVP should do less than you think</image:title>
      <image:caption>Every feature you add before launch delays the day you learn whether the product works. The discipline of cutting is what gets you to the truth faster, so your first version should do one thing well.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/why-your-staging-environment-is-lying-to-you</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-why-your-staging-environment-is-lying-to-you.webp</image:loc>
      <image:title>Why your staging environment is lying to you</image:title>
      <image:caption>Staging passed. Production broke. That is not bad luck, it is a predictable consequence of the five ways staging differs from the place your users actually are.</image:caption>
    </image:image>
  </url>
  <url>
    <loc>https://reveneau.com/insights/why-your-team-does-not-trust-the-ai-output</loc>
    <image:image>
      <image:loc>https://reveneau.com/site/assets/reveneau/blog-why-your-team-does-not-trust-the-ai-output.webp</image:loc>
      <image:title>Why your team does not trust the AI output</image:title>
      <image:caption>Distrust of AI-generated code is usually well calibrated. Engineers have been burned by output that was almost right, and the fix is verification they can watch, not another training session.</image:caption>
    </image:image>
  </url>
</urlset>
