<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Alex</title>
    <description>The latest articles on DEV Community by Alex (@aberger_).</description>
    <link>https://dev.to/aberger_</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4205359%2F1d6b1cec-1393-4f62-8d4a-9a69e3ec2c8d.png</url>
      <title>DEV Community: Alex</title>
      <link>https://dev.to/aberger_</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/aberger_"/>
    <language>en</language>
    <item>
      <title>Who's Actually Out of a Job?</title>
      <dc:creator>Alex</dc:creator>
      <pubDate>Wed, 18 Nov 2026 19:28:36 +0000</pubDate>
      <link>https://dev.to/aberger_/whos-actually-out-of-a-job-578g</link>
      <guid>https://dev.to/aberger_/whos-actually-out-of-a-job-578g</guid>
      <description>&lt;p&gt;I ended the &lt;a href="https://dev.to/aberger_/vibes-dont-maintain-3c85"&gt;last post&lt;/a&gt; with a question: if the tool can do my job, what was I still for?&lt;/p&gt;

&lt;p&gt;The people asking were mostly managers. It's worth looking at what they thought my job was - and what they thought theirs was - because I think they had both backwards.&lt;/p&gt;




&lt;p&gt;Start with the claim itself: a new tool will let people build software without understanding software. It's not new. No-code wasn't tried only once. It has been tried in every decade since computers got a mouse, and it died every time.&lt;/p&gt;

&lt;p&gt;Microsoft FrontPage, 1996. Drag a box, type some text, click publish. Nobody would ever have to code a website again. That's why web development as a profession ended in 1997.&lt;/p&gt;

&lt;p&gt;What actually happened is that FrontPage produced websites that looked like websites and behaved like a stack of pictures. The moment someone wanted a contact form that did something, or a page that changed based on who was looking at it, a developer got called. The tool collapsed the easy part to zero and left the hard part exactly where it was. Dreamweaver - FrontPage for people with taste - did the same thing with nicer defaults. Flash let you draw your way to a website that moved, right up until the platform itself was switched off and every one of those sites went dark on the same day.&lt;/p&gt;

&lt;p&gt;PowerPoint was never sold as a way to build software, and it never became one. What it became was the tool for click-dummies. Screen, arrow, screen, arrow, and you had an app you could click through in a meeting. Click-through prototypes - Balsamiq, InVision, later Figma - were the same idea with better fidelity. Or again, for the people with taste. The deck was never wrong, just incomplete. It just described a surface of the happy flow, and every arrow hid a hundred decisions about what happens when the thing on the other side of it fails. To be fair, nobody ever cared about the error messages anyways.&lt;/p&gt;

&lt;p&gt;Then Stack Overflow Driven Development. Search the error, paste the top answer, move on. It freed us from writing the code and, more importantly, from the guilt of not understanding it. If the internet hadn't said it was wrong, it was good enough. The rest was up to the compiler. Those codebases worked right up until they didn't, and then nobody could (or wanted to) say why any given block was there.&lt;/p&gt;

&lt;p&gt;Each of these had its moment, its conference talks, and its "developers are over" headlines. Each one quietly ended up back in the hands of the developers it was meant to replace - or ended, full stop.&lt;/p&gt;




&lt;p&gt;Agents like Claude Code, Codex, or Copilot are the same thing with the delay removed.&lt;/p&gt;

&lt;p&gt;FrontPage needed you to lay out the page. PowerPoint needed you to draw the arrows. Stack Overflow needed you to find the right answer and glue it in. An agent takes a sentence and does all three, in minutes, and the result runs.&lt;/p&gt;

&lt;p&gt;That's the real change. Not what's possible - how fast and how cheaply you reach the point where it &lt;em&gt;looks&lt;/em&gt; done. That point used to be weeks away. Now it's an afternoon. The distance between "looks done" and "is done" hasn't moved. It just shows up sooner and more convincingly, and the bill for crossing it arrives later and bigger.&lt;/p&gt;

&lt;p&gt;An agent can produce far more than FrontPage or PowerPoint ever could. But it shares one trait with the managers: it knows a nice-looking UI sells better than an hour-long monologue about the state machine behind an error case. Sex sells. Ask for an app and you get the parts that demo well.&lt;/p&gt;

&lt;p&gt;So someone has to tell it to build that state machine, its states how they transition. Then someone has to check that it's correct. That's just one example out of hundreds. A human developer built those things for two reasons: they knew they had to be built, and they knew it would come back to them if they didn't. It was part of the job. The agent doesn't care. It will tell you it built what you told it to, and it did. Thinking outside the box is your job.&lt;/p&gt;




&lt;p&gt;Now the part the managers got backwards.&lt;/p&gt;

&lt;p&gt;What did they think they brought to the table? The idea. The business case. The pitch. The deck with the arrows. What did they think we developers brought? Typing. The slow, expensive conversion of their vision into something that runs.&lt;/p&gt;

&lt;p&gt;If that were true, they'd be right to worry about us. The typing is what got cheap.&lt;/p&gt;

&lt;p&gt;But look at what my restaurant friend produced with an agent in an afternoon: a deck with arrows that runs. That is the manager's deliverable, delivered by the tool. Idea to surface, the first-meeting demo - the thing that used to justify a role - now costs nothing and requires no one.&lt;/p&gt;

&lt;p&gt;What it didn't produce is everything underneath. The seatbelts. The understanding of why it was built the way it was. The ability to open the hood when it breaks. That part didn't get cheaper. It got rarer, because fewer people on the way to the demo had to touch it. It's what we developers brought to the table all along, and we're still here, still bringing it.&lt;/p&gt;

&lt;p&gt;Here's my hypothesis, then: AI makes the manager more redundant than the engineer.&lt;/p&gt;

&lt;p&gt;Engineers can come up with ideas too. We always could but we were busy. If we really don't write the code anymore, that's a lot of afternoons freed up to notice what's missing, sketch it, and put it in front of someone. We can sell them - a working thing is the most persuasive pitch there is, and we can produce one as fast as anyone now. And when it goes wrong, we can fix it. That last one is the whole difference. The manager with an agent gets a click-dummy. The engineer with an agent gets a product, and keeps it running.&lt;/p&gt;




&lt;p&gt;So what does the engineer actually bring, if not the typing?&lt;/p&gt;

&lt;p&gt;A stack they know deeply. Not because Rails is better than Spring Boot or Laravel in the abstract, but because when something breaks at eleven at night you have to know where to look, and that knowledge doesn't come out of a prompt.&lt;/p&gt;

&lt;p&gt;Behavior written down before the code, as scenarios that run. If the &lt;em&gt;what&lt;/em&gt; is unambiguous, the &lt;em&gt;how&lt;/em&gt; is easier to read, easier to hand to an agent, and easier to verify when it comes back. The right architecture does the same for structure: the moving parts have names and places.&lt;/p&gt;

&lt;p&gt;And a record. Our stories, specs, and decisions are markdown files in git, kept with &lt;a href="https://github.com/bybacon/bacon-tracker" rel="noopener noreferrer"&gt;bacon-tracker&lt;/a&gt;. Markdown is human-readable and trivially safe to keep - and a folder of well-written markdown is enough to rebuild the whole thing from scratch, by a person or by whatever agent is current in three years. The code is disposable. The intent isn't.&lt;/p&gt;

&lt;p&gt;None of that is new either. It's what engineers did when the typing was the slow part, too. The tools just stripped away enough of the typing that you can finally see it was never the job.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;bacon-tracker is open source: &lt;a href="https://github.com/bybacon/bacon-tracker" rel="noopener noreferrer"&gt;github.com/bybacon/bacon-tracker&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>xp</category>
      <category>ai</category>
      <category>teams</category>
    </item>
    <item>
      <title>Vibes Don't Maintain</title>
      <dc:creator>Alex</dc:creator>
      <pubDate>Thu, 12 Nov 2026 18:37:45 +0000</pubDate>
      <link>https://dev.to/aberger_/vibes-dont-maintain-3c85</link>
      <guid>https://dev.to/aberger_/vibes-dont-maintain-3c85</guid>
      <description>&lt;p&gt;Since ChatGPT took off, people have been coming up to me to say some version of "you people will be out of a job soon."&lt;/p&gt;

&lt;p&gt;Most of them were managers. They knew it was provocative, and they wanted to see how I'd react - partly to test the waters on whether this was a real scenario. What they had in common was that none of them had a clear idea of what software development actually is. Not what it looks like from the outside. What it is.&lt;/p&gt;

&lt;p&gt;Last week I got the best version of that conversation I've had so far.&lt;/p&gt;




&lt;p&gt;A friend of mine owns a restaurant. He told me he'd built an app for it with Claude Code - a web app to manage tasks and processes for his staff. He was proud of it, and he had every right to be. He had never written a line of code and he had a thing on a screen that did what he described.&lt;/p&gt;

&lt;p&gt;I had a look. It was nice. Clean layout, sensible flow, data that persisted between page loads so it felt like a working system.&lt;/p&gt;

&lt;p&gt;Then I started poking. No responsive layout - it broke on the phones his staff would actually use. No dark mode 🏴‍☠️. No login, so no notion of who did what. No settings. No translations, in a kitchen where half the team doesn't speak the language the app was written in. No error states. No handling of the empty case, the duplicate case, the two-people-edit-the-same-thing case. The data "persisted" in a way that would survive a refresh and not much else.&lt;/p&gt;

&lt;p&gt;It was a click-dummy. A prototype. A perfectly good proof of concept for a first round of conversations about whether the idea holds up - which is a real and valuable thing to have.&lt;/p&gt;

&lt;p&gt;Then he asked me if I could host it for him and do ops.&lt;/p&gt;




&lt;p&gt;This is the biggest misunderstanding people have about software, and it has nothing to do with AI.&lt;/p&gt;

&lt;p&gt;People see the surface. They see the parts that work. They don't see the parts that run when something goes wrong, the parts that exist to stop things going wrong, or the parts that have never once executed in production because they're there for a worst case someone sat down and imagined.&lt;/p&gt;

&lt;p&gt;The seatbelt and the airbag in your car have, with luck, never done anything. That doesn't make them useless. You don't buckle up because the law says so or because the car beeps at you. You buckle up because you understand that one day you might need it. Software is mostly seatbelts. The happy path - the thing the demo shows - is the smallest part of the codebase.&lt;/p&gt;

&lt;p&gt;My friend, understandably, didn't see that. His read was that the app works 100% as intended, so 90% of the work is done. The rest is hosting. And I shouldn't overcomplicate it.&lt;/p&gt;




&lt;p&gt;Here's how that version plays out.&lt;/p&gt;

&lt;p&gt;The prototype came almost free and almost instantly. He decides the product is done. He might even get it in front of users - his staff start using it for real shifts, real tasks, real schedules.&lt;/p&gt;

&lt;p&gt;Then something goes wrong. The database file corrupts. A dependency update breaks something. Someone finds the app on the open internet and has a look around. An edge case fires that nobody wrote down. Or my personal favorite: daylight saving time, and every shift in the schedule is off by an hour.&lt;/p&gt;

&lt;p&gt;Everything goes boom.&lt;/p&gt;

&lt;p&gt;He doesn't know what he built. He doesn't know why it was built the way it was - the reasoning lived in a chat session that's gone. He doesn't know what to look for or where to start looking. There is no spec, no test, no document, no commit message that explains the intent of anything.&lt;/p&gt;

&lt;p&gt;At that point he has two options. Find someone to fix it and prepare to hand them all his money, because the first week of that engagement is pure archaeology. Or flee the country.&lt;/p&gt;

&lt;p&gt;That is what "vibes don't maintain" means in practice. The vibe got him to the demo. Nothing carried forward from there.&lt;/p&gt;




&lt;p&gt;None of this is "don't use AI." We use it every day. But two things are true at the same time.&lt;/p&gt;

&lt;p&gt;First: AI does not make you a software engineer if your background is baking bread, any more than your oven at home makes you a chef. It makes execution cheap. It does nothing about knowing what to execute, or what to do when the execution fails.&lt;/p&gt;

&lt;p&gt;Second: shit in, shit out. If the input is a loose description of what the happy path looks like, the output is a happy path. The AI will not invent the seatbelts for you. It doesn't know you'll need them, because you didn't.&lt;/p&gt;

&lt;p&gt;What survives a boom is not the code. It's the record of what the code was supposed to do - the stories, the specs, the decisions - written down somewhere a human or an agent can read them back. Ours are markdown files in git, kept with &lt;a href="https://github.com/bybacon/bacon-tracker" rel="noopener noreferrer"&gt;bacon-tracker&lt;/a&gt;. My friend has a chat history he can't find anymore.&lt;/p&gt;

&lt;p&gt;That record is what you're paying for. Not the click-dummy.&lt;/p&gt;

&lt;p&gt;There's a second question hiding in his request, and in all those "you'll be out of a job" conversations: if the tool really can do my job, what exactly was I still for? But that's for another day.&lt;/p&gt;




&lt;p&gt;I called him the next day. I told him I got myself a Thermomix - the one with AI - and was planning to open a restaurant the week after.&lt;/p&gt;

&lt;p&gt;He laughed. Then he went quiet for a second.&lt;/p&gt;

&lt;p&gt;I hope he got it. But knowing him I think he did not.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
      <category>programming</category>
    </item>
    <item>
      <title>XP Is More Important Now Than It Was Before AI</title>
      <dc:creator>Alex</dc:creator>
      <pubDate>Fri, 06 Nov 2026 08:25:57 +0000</pubDate>
      <link>https://dev.to/aberger_/xp-is-more-important-now-than-it-was-before-ai-g6a</link>
      <guid>https://dev.to/aberger_/xp-is-more-important-now-than-it-was-before-ai-g6a</guid>
      <description>&lt;p&gt;There's a common assumption floating around that AI coding tools make software engineering practices like BDD, pairing, and XP less necessary. The machine writes the code, so the ceremony around how humans collaborate to produce code matters less.&lt;/p&gt;

&lt;p&gt;This assumption is backwards.&lt;/p&gt;

&lt;p&gt;AI makes execution cheap. It makes the wrong thing fast to build. And it makes the cost of unclear requirements higher than it has ever been.&lt;/p&gt;

&lt;p&gt;The practices that XP gave us - writing behavior first, pairing to share understanding, framing stories before starting work - exist precisely to produce clarity before execution. When execution was slow and expensive, fuzzy requirements were tolerable because you had time to correct course. Now execution is fast and cheap, and fuzzy requirements produce wrong software at previously impossible speed.&lt;/p&gt;

&lt;p&gt;XP is the meta-skill for the AI age.&lt;/p&gt;




&lt;p&gt;Let me be specific about what I mean.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;BDD when an AI is writing your code&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Behavior-driven development always had two jobs. The obvious one: produce test coverage. The less obvious one: force a conversation about what the software should actually do before anyone writes any code.&lt;/p&gt;

&lt;p&gt;The second job is now more important than the first.&lt;/p&gt;

&lt;p&gt;When you write a Gherkin scenario - &lt;code&gt;Given a user has an empty cart, When they add an item, Then the cart total reflects the item price&lt;/code&gt; - you are not primarily writing a test. You are making the expected behavior concrete enough that anyone, human or machine, can implement it unambiguously.&lt;/p&gt;

&lt;p&gt;An AI given a good set of BDD scenarios will implement them correctly. An AI given a vague story ("add cart functionality") will implement something that seems plausible, tests green, ships to staging, and fails the demo because nobody specified what happens to the cart total when a coupon code is applied, or when the same item is added twice, or when the item goes out of stock between add and checkout.&lt;/p&gt;

&lt;p&gt;This was always the failure mode. AI just accelerates it.&lt;/p&gt;

&lt;p&gt;The teams I've seen do this well treat their BDD scenarios as the authoritative source of truth for what they're building, not as an afterthought that follows implementation. They write the scenarios in the discovery session, before any code exists, with the product owner in the room. Then they hand those scenarios to the AI.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Pairing when one pair is an AI&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Pairing changed when AI became a capable programming partner. You can now pair with something that knows every library, never needs to look up syntax, is available at 2am, and doesn't get frustrated with your keyboard shortcuts.&lt;/p&gt;

&lt;p&gt;What it doesn't do: push back on your approach. Ask if you've considered the edge case. Notice that you've been working toward the wrong abstraction for the last hour. Say "wait, what are we actually trying to accomplish here?"&lt;/p&gt;

&lt;p&gt;Human pairing at its best is a conversation about intent. Two developers at a keyboard are not just two people writing code - they're two people keeping each other honest about what the code is for and whether the current approach is going to get there. The navigator isn't just watching. They're maintaining the map.&lt;/p&gt;

&lt;p&gt;AI pair programming is more like autocomplete with opinions. It's extremely good at the local, immediate task. It has no view of the larger goal unless you give it one. It will helpfully implement a design you described poorly and produce something that technically works and conceptually misses.&lt;/p&gt;

&lt;p&gt;This is why I still pair with humans. Not because the AI isn't useful - it's indispensable - but because my human pair provides something the AI can't: they remember what we were trying to do, they notice when I drift, and they'll say "I don't think we need this" in a way that I'll actually hear.&lt;/p&gt;

&lt;p&gt;The pairing practice that works in 2026 looks like this: human pair sets the direction and holds the intent, AI handles the implementation details, human pair reviews what came out. The roles shifted. The practice didn't.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Discovery and framing when AI can generate stories&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The hardest lesson from working with AI on story writing is that it can generate plausible-looking user stories very quickly and they're often subtly wrong.&lt;/p&gt;

&lt;p&gt;The output looks right. The format is correct. The acceptance criteria seem complete. And then you get to refinement and realize the story assumes a user flow that doesn't match how the feature was actually designed, or bring together two different types of users, or skips an entire edge case that your domain expert would have caught in the first five minutes.&lt;/p&gt;

&lt;p&gt;Discovery and framing exists because the gap between what stakeholders want and what developers build is a communication problem, not a technology problem. AI doesn't close that gap. It papers over it faster.&lt;/p&gt;

&lt;p&gt;The D&amp;amp;F sessions I've been part of that work well use AI for synthesis - pulling together notes, drafting story text after the conversation, generating scenario outlines - but keep the conversation itself human. The stakeholder explaining why this feature matters. The developer asking "what happens if the user doesn't have this permission." The product manager reconciling two contradictory requirements from two different teams.&lt;/p&gt;

&lt;p&gt;That conversation is the product. The story document is just the record of it.&lt;/p&gt;




&lt;p&gt;What I'm not saying: that you need to follow the full XP playbook to ship software with AI tools. You don't. Plenty of teams are shipping without written BDD scenarios or pairing sessions, and some of them are fine.&lt;/p&gt;

&lt;p&gt;What I am saying: the failure modes are more severe now. If your requirements are vague, AI builds the vague thing with confidence. If nobody holds the intent, the AI follows the path of least resistance and you end up with a technically functional system that doesn't actually solve the problem.&lt;/p&gt;

&lt;p&gt;The practices XP named - write the behavior first, keep two people watching the same screen, do the clarity work before the execution work - are responses to a enduring problem in software: that building the wrong thing is easier than building the right thing.&lt;/p&gt;

&lt;p&gt;AI made execution dramatically cheaper. It did nothing about the problem of knowing what to build.&lt;/p&gt;

&lt;p&gt;The clarity work is still yours.&lt;/p&gt;

</description>
      <category>xp</category>
      <category>ai</category>
      <category>developers</category>
      <category>testing</category>
    </item>
    <item>
      <title>The Spec That Runs</title>
      <dc:creator>Alex</dc:creator>
      <pubDate>Tue, 27 Oct 2026 15:49:24 +0000</pubDate>
      <link>https://dev.to/aberger_/the-spec-that-runs-1e66</link>
      <guid>https://dev.to/aberger_/the-spec-that-runs-1e66</guid>
      <description>&lt;p&gt;Every team has two representations of what their software should do. The first lives in the project management tool - Jira tickets, Notion pages, PRDs, whatever they're using. The second lives in the test suite. Both are supposed to describe the same behavior. They rarely do.&lt;/p&gt;

&lt;p&gt;The ticket says "Users can filter search results by category." The test says &lt;code&gt;expect(response.body).to include('Electronics')&lt;/code&gt;. These are not the same specification. One is a product intention. The other is an implementation artifact. As the product evolves, tickets stay frozen, tests get updated, and the two drift apart.&lt;/p&gt;

&lt;p&gt;This is the default state. Most teams live with it.&lt;/p&gt;

&lt;p&gt;Spec-driven development is the refusal to accept that drift as inevitable.&lt;/p&gt;




&lt;p&gt;The core idea is simple: the spec and the test should be the same document. Not two documents that describe the same behavior. One document, in a form that is both human-readable and machine-executable.&lt;/p&gt;

&lt;p&gt;This is what Gherkin gives you. A feature file is a requirements document that runs. It describes what the system should do, who benefits, and what specific behaviors constitute done - in language a product manager can read and a test runner can execute.&lt;/p&gt;

&lt;p&gt;For a booking management feature start like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight gherkin"&gt;&lt;code&gt;&lt;span class="kd"&gt;Feature&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; Booking Manager

As Molly
I want to manage Bookings for my Events
So that I can track who is attending, who is waitlisted, and who canceled

&lt;span class="kn"&gt;Scenario&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; Arthur books a spot for an available Event
  &lt;span class="nf"&gt;Given &lt;/span&gt;Molly has an available Event with open capacity
  &lt;span class="nf"&gt;When &lt;/span&gt;Arthur visits the new booking page for the Event
  &lt;span class="nf"&gt;And &lt;/span&gt;Arthur fills in his name and email address
  &lt;span class="nf"&gt;And &lt;/span&gt;Arthur submits the booking
  &lt;span class="nf"&gt;And &lt;/span&gt;Arthur confirms the booking via the email link he got
  &lt;span class="nf"&gt;Then &lt;/span&gt;Arthur should see the booking on the Event bookings list
  &lt;span class="nf"&gt;And &lt;/span&gt;The booking should be confirmed
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That file is the spec. It describes behavior that matters to actual users in a form that survives a demo, a PM review, and a CI pipeline. The same document does all three jobs.&lt;/p&gt;




&lt;p&gt;There's a second part of spec-driven development that doesn't get enough attention: the order.&lt;/p&gt;

&lt;p&gt;The spec runs first. Before any implementation exists.&lt;/p&gt;

&lt;p&gt;You write the feature file. You write the step definitions. You run the suite. It fails. That failure - the red - is the most important moment in the process. It proves the spec was written correctly, that the test infrastructure is wired up, and that when you write code to make it pass, the green result actually means something.&lt;/p&gt;

&lt;p&gt;This sounds obvious. Teams skip it constantly.&lt;/p&gt;

&lt;p&gt;The way it usually gets skipped: someone implements a feature, then writes the spec to document what they built. The spec runs green on the first try. Everyone feels good. The problem is you have no idea if that test would catch a broken implementation. You only know it doesn't catch the current one. You wrote a test that proves the present state, not one that will catch the future regression.&lt;/p&gt;

&lt;p&gt;The red proves the spec was real. Without it, you just have green.&lt;/p&gt;




&lt;p&gt;Where the spec lives matters as much as what it says.&lt;/p&gt;

&lt;p&gt;Most teams keep specs in the test directory of the codebase, isolated from wherever product requirements live. This creates the same split in a different location: requirements in one system, tests in another.&lt;/p&gt;

&lt;p&gt;The pattern that works is keeping specs in version control alongside everything else - treating them as the primary product artifact, not a byproduct of implementation.&lt;/p&gt;

&lt;p&gt;For us, feature files live in a &lt;code&gt;docs/&lt;/code&gt; directory with sequential IDs: &lt;code&gt;BCN-001-booking-manager.feature&lt;/code&gt;, &lt;code&gt;BCN-002-authentication-manager.feature&lt;/code&gt;. Each file has frontmatter tracking its status. Features move through four stages: &lt;code&gt;1_icebox&lt;/code&gt; → &lt;code&gt;2_backlog&lt;/code&gt; → &lt;code&gt;3_started&lt;/code&gt; -&amp;gt; &lt;code&gt;4_done&lt;/code&gt;. The stack-ranked backlog is a text file, also in git.&lt;/p&gt;

&lt;p&gt;There is no Jira. No Linear. The spec is the story is the ticket is the test.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/bybacon/bacon-tracker" rel="noopener noreferrer"&gt;bacon-tracker&lt;/a&gt; is the tooling that makes this concrete:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;rake story:feature['Booking Manager']  → features/1_icebox/BCN-001-booking-manager.feature
rake story:commit[BCN-001]             → moves to 2_backlog, adds to backlog.md
rake story:start[BCN-001]              → moves to 3_started
rake story:done[BCN-001]               → moves to 4_done
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Git becomes the audit trail. The story file is the commit. The test run is the verification. Nothing external can drift from what the code actually does, because there is no external system.&lt;/p&gt;




&lt;p&gt;The caveat: good Gherkin is harder to write than it looks.&lt;/p&gt;

&lt;p&gt;Bad Gherkin is a Jira ticket in a different format. It's either vague ("When the user does something / Then it works"), or over-specified ("Given the database has a User record with id=4 and email='&lt;a href="mailto:test@example.com"&gt;test@example.com&lt;/a&gt;'"), or it describes implementation instead of behavior.&lt;/p&gt;

&lt;p&gt;Good Gherkin describes behavior at the level of abstraction where the test catches regressions that actually matter. "When Arthur submits the booking / Then the booking should be confirmed" is a behavior. "When &lt;code&gt;POST /bookings&lt;/code&gt; is called with valid params / Then &lt;code&gt;response[:status]&lt;/code&gt; is &lt;code&gt;confirmed&lt;/code&gt;" is an implementation test wearing a Gherkin costume. The first survives refactoring. The second breaks every time you touch the internals.&lt;/p&gt;

&lt;p&gt;The tooling creates the structure. The thinking that goes into the scenarios is still yours.&lt;/p&gt;




&lt;p&gt;The deeper value of spec-driven development is not test coverage. It's clarity.&lt;/p&gt;

&lt;p&gt;When the spec runs, you know exactly where you stand. Green scenarios are done. Red scenarios are not. There is no ambiguity about what done means, because done is defined in executable form.&lt;/p&gt;

&lt;p&gt;That's rare in software. Most teams operate with done as a matter of interpretation - does it match the ticket? Does it match what the PM remembers from the meeting? Does it pass QA's judgment call? Each layer of interpretation is a place where the thing you built can drift from the thing that was needed.&lt;/p&gt;

&lt;p&gt;A spec that runs eliminates most of that drift. Not by adding accuracy, but by collapsing two separate representations of truth into one.&lt;/p&gt;

</description>
      <category>xp</category>
      <category>gherkin</category>
      <category>opensource</category>
      <category>testing</category>
    </item>
  </channel>
</rss>
