<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by An Tran on Medium]]></title>
        <description><![CDATA[Stories by An Tran on Medium]]></description>
        <link>https://medium.com/@an.tran_99237?source=rss-9e4e7891de88------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*DlOUTu9Of8Ev5OXu</url>
            <title>Stories by An Tran on Medium</title>
            <link>https://medium.com/@an.tran_99237?source=rss-9e4e7891de88------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:52:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@an.tran_99237/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Spec-First Parallel AI Development: Early Lessons from a Two-Week Trial]]></title>
            <link>https://medium.com/fsmk-engineering/spec-first-parallel-ai-development-early-lessons-from-a-two-week-trial-64aa33ab64e6?source=rss-9e4e7891de88------2</link>
            <guid isPermaLink="false">https://medium.com/p/64aa33ab64e6</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[fintech-startups]]></category>
            <category><![CDATA[ai-development]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[rails]]></category>
            <dc:creator><![CDATA[An Tran]]></dc:creator>
            <pubDate>Wed, 08 Oct 2025 02:08:58 GMT</pubDate>
            <atom:updated>2025-10-08T02:08:58.382Z</atom:updated>
            <content:encoded><![CDATA[<p>At Funding Societies, we’re always exploring ways to ship features faster while maintaining our quality standards. Recently, we ran a two-week trial testing a new approach where one engineer coordinates multiple Claude Code agents working in parallel on separate parts of a feature.</p><p>The methodology relies on five key elements:</p><ol><li>Detailed specification documents that capture all decisions and requirements</li><li>Pattern libraries with concrete examples</li><li>Complete, self-contained feature segments that work independently</li><li>Fresh AI sessions per PR to maintain focus</li><li>Specialized review assistants that catch mistakes before human review</li></ol><p><strong>Security and Privacy Note</strong>: We conducted this experiment using Claude Code within an isolated development environment. We worked exclusively with code samples and synthetic test data — no customer data, credentials, or secrets were shared with external services. All changes passed human code review, automated tests, and security scans before merge.</p><p><strong>TL;DR</strong>: We ran a short, controlled pilot pairing engineers with AI coding agents on a migration task. By front-loading specification and using independent vertical slices, we saw ~40% improvements in internal throughput and ~50% reduction in cycle time without changing our security, review, or testing gates. The gains were uneven: they were strongest where work decomposed cleanly, and weakest in multi-layer debugging. We’re now running a 30–60 day validation using DORA-style indicators.</p><h3>Table of Contents</h3><ol><li><a href="https://medium.com/@an.tran_99237/64aa33ab64e6#1-background">Background</a></li><li><a href="https://medium.com/@an.tran_99237/64aa33ab64e6#2-the-experiment-plan-first-build-in-parallel">The Experiment: Plan First, Build in Parallel</a></li><li><a href="#3-code-review-and-refinement">Code Review and Refinement</a></li><li><a href="#4-what-we-observed">What We Observed</a></li><li><a href="#5-challenges-and-limitations">Challenges and Limitations</a></li><li><a href="#6-our-engineering-role-changed">Our Engineering Role Changed</a></li><li><a href="#7-conclusion">Conclusion</a></li></ol><h3>1. Background</h3><h3>The Business Context</h3><p>We have been migrating legacy Rails systems to modern Go APIs for a while. When working on the next batch of features to migrate, we saw multiple big features estimated to take up to 4 weeks to migrate by one developer. We’d been using AI tools for several months for specific tasks like code generation and test writing, but we sensed we could do more. By 2025, AI coding tools had become really powerful; they could understand complex requirements, build entire features, and keep code consistent across large projects.</p><p>We saw an opportunity to challenge ourselves: <strong>What if we took a feature that would typically take 4 weeks for one engineer and tried to finish it faster by working with multiple AI agents simultaneously?</strong></p><p>For our experiment, we chose to migrate a legacy reward program built in Rails — to our new Go service. This feature allows users to generate user codes, share them with friends, and earn rewards when friends successfully sign up. The system includes code generation, validation pipelines, reward tracking, and redemption flows with different business rules across regions.</p><h3>Our Hypothesis</h3><p>Traditionally, engineers work through features one step at a time — implement, review, merge, repeat. What if we could explore a different approach?</p><p><strong>Here’s what we wanted to test:</strong></p><ul><li><strong>Traditional approach</strong>: One engineer, 4 weeks, working step by step</li><li><strong>Our experiment</strong>: One engineer guiding 2–3 AI agents working simultaneously, perhaps finishing in 2 weeks</li><li><strong>The key</strong>: Breaking work into independent pieces that could happen in parallel</li></ul><p>The diagram shows our thinking: instead of writing all the code ourselves, what if we could guide three AI agents, each focused on different parts? We thought it was worth exploring.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vUPUIX72DxqPAwDuN7BSAA.png" /><figcaption>Multi-Agent Development Hypothesis</figcaption></figure><h3>How We Set Up Our Development Workflow</h3><p>To make parallel AI development work, we refined our existing workflow to take advantage of what AI does best. Here’s what our setup looked like:</p><ol><li><strong>AI-powered documentation cycle</strong> — AI writes better code when it has better documentation. We used AI to analyze our legacy system and create comprehensive technical documentation, implementation plans, user stories, and pattern guides that humans and AI could understand perfectly.</li><li><strong>Parallel end-to-end development</strong> — We designed work so that 2–3 AI agents could each implement a complete vertical slice of the feature. Each agent would work sequentially through their slice — models, repository, service, tests — but multiple agents did this in parallel on different slices. For example, while Agent 1 built the entire code generation flow end-to-end, Agent 2 implemented the complete validation pipeline. Each owned their piece from the database to the API, working independently without blocking others.</li><li><strong>Small PRs for fast iteration</strong> — We’ve always kept PRs under 100 lines as a team practice, but this turned out to be perfect for AI development. Small PRs make it easy to spot and correct AI mistakes before they compound — you can review in seconds, provide feedback immediately, and get back on track. With AI, this practice became even more powerful: most PRs went from creation to merge in 30 minutes to 2 hours.</li><li><strong>Living pattern documentation</strong> — We documented our team’s coding patterns in detail, including how we structure each layer, handle errors, write logs, and organize tests. We created pattern files with real examples from our codebase, not just rules. The AI-generated code almost always conformed to these patterns perfectly. When we spotted any ambiguity in AI output — maybe a variable naming inconsistency or a slightly different error handling approach — we immediately updated our pattern docs to be clearer. This continuous refinement meant the patterns improved over time, and AI code became increasingly indistinguishable from what our team would write.</li></ol><p>With this workflow in place, we were ready to put our hypothesis to the test.</p><h3>2. <strong>The Experiment: Plan First, Build in Parallel</strong></h3><p>Our approach had two clear stages: first, we used one AI agent to understand what we were building, then we unleashed multiple agents to construct different parts simultaneously.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xvG1v4ZwCE8vUfgP321z4Q.png" /><figcaption>Two-stage implementation</figcaption></figure><h3>Stage 1: Planning with AI</h3><p>Before we could coordinate multiple AI agents working in parallel, we needed clear plans for each to follow. We used AI to accelerate this discovery phase — analyzing the legacy system and creating detailed specifications.</p><p><strong>Phase 1: Understanding the Legacy System</strong></p><p>First, we needed to understand what already existed. We pointed AI at our legacy systems and got back comprehensive documentation:</p><ul><li><strong>Multiple key database tables</strong>: Complete schema and relationships documented</li><li><strong>ActiveRecord models</strong>: Business logic extracted with all validations and callbacks</li><li><strong>16-step validation pipeline</strong>: Existing flow that needed extension for a new feature</li><li><strong>Region-specific configurations</strong>: Different rules for different regions/markets</li><li><strong>Multiple system integration points</strong>: How different services interact</li></ul><p>This analysis gave us a deep understanding that would have taken weeks to build manually.</p><p><strong>Phase 2: Clarifying What to Build</strong></p><p>Understanding the existing system was just the starting point. Next, we needed to clarify what we wanted to build. We asked AI to identify gaps in our understanding and generate questions we needed to answer:</p><ul><li>What format should user codes use?</li><li>When do users get rewards — immediately or after verification?</li><li>What happens with expired or already-used codes?</li><li>How should this work with our existing validation system?</li></ul><p>We answered each question to define what we wanted to build. AI turned our answers into clear documentation.</p><p><strong>Phase 3: Creating the Implementation Plan</strong></p><p>With requirements clarified, we needed an actionable plan. We used AI to create detailed specifications:</p><ul><li><strong>Execution roadmap</strong>: A structured approach with clear phases and dependencies</li><li><strong>Effort estimation</strong>: Initial timeline projections that we could refine as we learned more</li><li><strong>Architectural decisions</strong>: Key choices like extending our existing validation pipeline rather than building from scratch</li><li><strong>Implementation scope</strong>: Complete picture of files and components that would need creation or modification</li><li><strong>Testing approach</strong>: Strategy focused on HTTP integration tests for reliable validation</li></ul><p>This planning gave us confidence that we understood what to build and how to build it.</p><p><strong>Phase 4: Breaking Work into Independent Pieces</strong></p><p>Finally, we needed to organize work so multiple AI agents could build in parallel. Instead of creating new technical breakdowns, we used the user stories our product team had already defined:</p><ul><li><strong>Feature A: Generate User Codes</strong> — The core user code creation system</li><li><strong>Feature B: View Codes via API</strong> — New API for dashboard access</li><li><strong>Feature C: Validate Code Enhancement</strong> — Extending the existing validation pipeline</li><li><strong>Feature D: Code Redemption</strong> — Redemption flow integration</li><li><strong>Feature E: Statistics API</strong> — Analytics and monitoring capabilities</li></ul><p>Each story represented a complete feature that delivered customer value. Using existing product stories meant we could communicate progress in business terms that everyone understood.</p><p>The key insight: once we built core models and basic infrastructure, we could guide multiple AI agents simultaneously, each focused on different user stories built upon the shared foundation.</p><h3>Stage 2: Building in Parallel</h3><p>With planning complete, we could finally test our core hypothesis: could multiple AI agents working simultaneously compress our timeline from 4 weeks to 2 weeks?</p><p>The answer was yes, but it required the right setup.</p><p><strong>Setting Up the Workspace</strong></p><p>First, we needed a workspace where multiple agents could work independently. We organized it like separate workbenches for each AI agent, with shared blueprints they could all reference.</p><p>Here’s the structure:</p><pre>workspace/<br>├── specifications/                     # Shared context for all agents<br>│   ├── analysis/                       # Discovery phase outputs<br>│   │   ├── legacy_analysis.md          # Comprehensive system understanding<br>│   │   ├── requirements_final.md       # Clarified business rules<br>│   │   └── questionnaire_answers.md    # Complete Q&amp;A documentation<br>│   ├── plans/                          # Implementation roadmaps<br>│   │   ├── implementation_plan.md      # Master plan with phases<br>│   │   ├── effort_estimation.md        # Time estimates<br>│   │   └── task_sequencing.md          # Optimized execution order<br>│   └── stories/                        # Independent story breakdowns<br>│       ├── feature-a_generation.md<br>│       ├── feature-b_api.md<br>│       └── ...<br>├── implementation/                     # Per-story execution tracking<br>│   ├── 002__feature-a_generation/<br>│   │   ├── 001__attempt_1/<br>│   │   │   ├── implementation.md       # PR breakdown &amp; status<br>│   │   │   ├── feedback.md             # Pattern corrections<br>│   │   │   └── branches.txt            # Active branch tracking<br>│   │   └── prompts/<br>│   │       ├── plan_prompt.md          # Standard planning prompt<br>│   │       └── continue_prompt.md      # Continuation instructions<br>│   └── 003__feature-b_api/<br>└── patterns/                           # Living style guide<br>    ├── STYLE_GUIDE.md                  # Quick reference guide<br>    └── detailed/                       # Pattern library<br>        ├── 01-patterns__errors.md      # Error handling patterns<br>        ├── 01-patterns__models.md      # Domain model patterns<br>        ├── 01-patterns__repositories.md # Data access patterns<br>        ├── 01-patterns__services.md    # Service layer patterns<br>        ├── 02-testing.md               # HTTP-first test approach<br>        └── 03-architecture.md          # DDD and layering rules</pre><p><strong>Coordinating Multiple Agents</strong></p><p>The key to coordination was implementation.md files. These living documents served as the coordination center for each story.</p><p>Each story folder contained an implementation.md file—a detailed plan that broke down the user story into smaller steps. The focus was speed and fast feedback loops: AI completes each step quickly, we course correct if needed, and we review each PR in under 5 minutes. This enabled any Claude Code session to pick up exactly where the previous session left off.</p><p>Each file contained:</p><ul><li><strong>Status tracker</strong>: Real-time progress of each PR (completed, in progress, pending)</li><li><strong>Current branch</strong>: Which git branch should the agent be working on</li><li><strong>PR-by-PR breakdown</strong>: Clear scope and specific file changes for each component</li><li><strong>Auto-continue instructions</strong>: How can any AI session pick up work seamlessly</li></ul><p><strong>Example implementation tracking:</strong></p><pre>## Status Tracker<br><br>| Status           | PR      | Component     | Result               |<br>|------------------|---------|---------------|----------------------|<br>| ✅ **Completed** | PR #1   | API Models    | Implemented &amp; Tested |<br>| ✅ **Completed** | PR #2   | Repository    | Implemented &amp; Tested |<br>| ✅ **Completed** | PR #3   | Service       | Implemented &amp; Tested |<br>| ✅ **Completed** | PR #4   | Controller    | Implemented &amp; Tested |<br>| ✅ **Completed** | PR #5   | Integration   | Implemented &amp; Tested |<br>| 📋 **Total**     | 5/5 PRs | 100% Complete | **FEATURE COMPLETE** |</pre><p>This tracking system enabled any AI session to quickly identify what was completed, in progress, and pending — eliminating context confusion when running multiple agents or restarting sessions.</p><p><strong>Running Multiple Agents</strong></p><p>With our workspace ready, we could test the core idea: running multiple AI agents simultaneously. Here’s how it worked.</p><p>We focused on four user stories that AI agents could build independently:</p><ul><li><strong>Feature A</strong>: Generate user codes (core creation logic)</li><li><strong>Feature B</strong>: Customer API for viewing codes (new API endpoints)</li><li><strong>Feature C</strong>: Create user records during payment flow</li><li><strong>Feature E</strong>: Statistics API for analytics dashboard</li></ul><p>We opened 2–3 terminal sessions, each running its own AI agent:</p><pre># Terminal 1: Feature A Generation<br>$ &quot;&gt; help me with implementation/002__feature-a_generation/implementation.md&quot;<br><br># Terminal 2: Feature B API<br>$ &quot;&gt; help me with implementation/003__feature-b_api/implementation.md&quot;<br><br># Terminal 3: Feature C Validation<br>$ &quot;&gt; help me with implementation/004__feature-c_validation/implementation.md&quot;</pre><p>Each agent would pick up exactly where the previous session left off, work through the next PR in sequence, and update the progress tracker. The key insight was that once our database models were established, multiple AI agents can build different functional areas simultaneously without conflicts — one agent handling code generation, another building analytics APIs, and a third extending validation pipelines.</p><p>This parallel approach worked because of four essential elements: self-contained implementation files with auto-continue instructions, clear PR boundaries preventing overlap, frequent merges to share completed work, and consistent coding patterns that made AI output predictable.</p><p>The implementation.md files included specific instructions like “review current progress,” “implement next step,” and “update tracker,” allowing any AI session to pick up exactly where needed without confusion.</p><h3>3. Code Review and Refinement</h3><p>Running multiple AI agents in parallel revealed a quality challenge. While Claude Code could understand our patterns when explained, it would consistently miss some in the actual implementation. We’d repeatedly fix the same issues — verbose variable names, inconsistent error handling, or missing validations.</p><p>This became frustrating when working across multiple stories. Instead of focusing on development, we spent time providing repetitive feedback about pattern violations.</p><p><strong>Using Specialized Subagents</strong></p><p>We realized we could use Claude Code’s subagent system. Subagents are specialized AI assistants with their own context windows. Instead of having the main Claude Code session implement features and check patterns simultaneously, we delegated pattern checking to a dedicated code-reviewer subagent.</p><p>This subagent focused entirely on scanning for pattern violations. Each AI assistant could excel at its specific task — one for coding, one for quality checking.</p><p><strong>The Review Process</strong></p><p>The workflow was simple:</p><pre># After implementation completes<br>$ &quot;&gt; @code-reviewer please review the current PR&quot;</pre><p>The code-reviewer subagent would analyze the changes and categorize findings by priority:</p><ul><li><strong>Critical</strong>: Pattern violations (must fix)</li><li><strong>Major</strong>: Missing error handling (should fix)</li><li><strong>Minor</strong>: Variable naming, comment clarity (nice to have)</li></ul><p>Then Claude Code could address issues with specific, targeted guidance:</p><pre>$ &quot;&gt; address the critical and major review comments&quot;</pre><p>The code-reviewer subagent pinpointed exactly where patterns were missed and explained the issues clearly. This eliminated the repetitive feedback cycle.</p><p><strong>Improving Over Time</strong></p><p>Each story folder included feedback.md files that captured recurring issues. When we noticed the same problem across multiple stories, we&#39;d update our style guide to prevent it everywhere.</p><p>For example, after seeing repeated verbose variable naming, we added:</p><pre># Variable Naming: Use concise helper variable names (`m` for mapper, not `sqlMapper`)</pre><p>This created a feedback loop: our patterns became more comprehensive over time, and later stories required fewer corrections.</p><h3>4. <strong>What We Observed</strong></h3><h3><strong>Throughput and Quality Metrics</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OKssoAuJAyN1KMM-CC-jcA.png" /><figcaption>PR Volume Comparison</figcaption></figure><p>The charts above compare our two-week trial against a matched baseline period. We observed ~40% higher PR throughput. We were simultaneously learning new coordination patterns, refining implementation processes, and establishing our parallel AI workflow during the experiment period.</p><p>But measuring throughput alone tells an incomplete story. An important question remains: did this come at the cost of quality? This is where standardized engineering metrics would be valuable.</p><p>The industry-standard DORA metrics would help measure both speed and quality dimensions. However, meaningful quality assessment requires time. Change failure rates need sufficient deployment cycles to be statistically meaningful. Recovery patterns typically emerge over months, not weeks. This is why we’re conducting extended 30–60 day validation studies using change-failure rate, rework ratio, and escaped-defect counts.</p><p>The larger question isn’t whether we can ship faster for two weeks — it’s whether a spec-first parallel approach might enable sustained speed without compromising production quality.</p><p><strong>Important Context</strong>: These figures reflect a time-boxed pilot in a non-production environment on a subset of migration tasks, compared with a matched internal baseline. They are directional indicators, not representative of company-wide output.</p><h3><strong>AI Interaction Efficiency</strong></h3><p>The basic metric we considered was the input/output ratio — ideally, you want to maximize output while minimizing input.</p><p>During the experiment, our patterns and practices were evolving rapidly. We were learning how to structure the implementation.md files, refining our CLAUDE.md patterns, and discovering what worked for parallel AI coordination. This constant evolution means any patterns in our data should be viewed as preliminary observations.</p><p>With that context in mind, here’s what our dataset across multiple git branches showed:</p><ul><li><strong>Average: 23.4 messages per branch</strong></li><li><strong>Median: 20 messages per branch</strong></li><li><strong>Most branches (75%) required fewer than 30 messages</strong></li><li><strong>About 10% required extensive iteration (30+ messages)</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ck49K7JZsbB-DN3BwLFvOQ.png" /><figcaption>Branch Distribution by User Prompt</figcaption></figure><p><strong>What Drove These Numbers</strong></p><p>We front-loaded complexity into our markdown specifications. Instead of explaining context and requirements in every interaction, we wrote a detailed implementation.md files once, then used simple prompts like “help me with implementation.md” repeatedly.</p><p>The chart shows this approach working for most branches, but the high-interaction outliers tell an interesting story. These typically fell into three categories: pattern development (especially early on), complex validation logic, and multi-layer debugging challenges.</p><p>Notably, many high-interaction branches occurred early in our experiment, suggesting we were building reusable patterns from which later work could benefit. This temporal pattern raises an intriguing possibility. Front-loading effort into comprehensive planning and pattern development might reduce ongoing interaction costs — representing a fundamentally different approach to AI-assisted development.</p><p>Of course, with just two weeks of rapidly evolving practices, we can’t separate learning curve effects from genuine efficiency differences. Validating this hypothesis would require much longer studies with stable methodologies and proper controls — but it’s a question worth exploring as more teams experiment with similar approaches.</p><h3>5. Challenges and Limitations</h3><p>While we observed promising throughput improvements, we also discovered areas where the approach required more attention than expected. These experiences helped us understand both the potential and the practical considerations of parallel AI development.</p><h3>AI Context Degradation</h3><p>AI sessions gradually lose clarity over extended periods. After 2–3 hours of intensive work, agents would begin mixing patterns, forgetting previous decisions, and generating less consistent code.</p><p>Fresh sessions for each PR became our standard practice, though this creates a trade-off. While each agent starts with a clear context for its specific task, it needs to re-read implementation files and loses the accumulated system understanding from previous sessions. This costs additional tokens and time, but gives more reliable results. This pattern shaped how we structure work into smaller, more focused chunks:</p><pre># Instead of marathon sessions<br>$ &quot;&gt; implement entire story-001&quot;  # ❌ Degrades over time<br><br># We used focused sprints<br>$ &quot;&gt; implement PR #1 for story-001&quot;  # ✅ Clear and focused<br># Complete PR, merge, start new session<br>$ &quot;&gt; implement PR #2 for story-001&quot;  # ✅ Fresh context</pre><h3>Verification and Citation Challenges</h3><p>AI can occasionally generate plausible-sounding code examples when referencing legacy systems. While this happened rarely, when Claude Code did create convincing code snippets rather than searching our actual Rails reference codebase, it was problematic:</p><pre># Was this real legacy code or AI assumption?<br>def calculate_user_bonus(amount, tier)<br>  base_rate = RATES[tier] || 0.05<br>  amount * base_rate<br>end</pre><p>Without file paths and line numbers, we couldn’t easily distinguish between actual legacy patterns and AI assumptions about how the code “probably” worked.</p><p>We developed verification practices: emphasizing that Claude Code should search existing Rails reference code when analyzing legacy systems, asking for file paths and line numbers whenever AI shows code snippets from legacy codebases, and spot-checking referenced code to verify citations.</p><p>Verification takes time and attention that traditional development doesn’t require. This “trust but verify” approach works well once you establish the habit, though it does add a layer of checking to the development process.</p><h3>Complex Debugging</h3><p>We write functional integration tests that cover all the layers of the system. When these tests failed, we observed Claude Code struggling with complex validation chains spanning multiple layers — model validations, service business rules, database constraints, and HTTP controller checks.</p><p>Claude Code would often fix one layer while breaking another. It might add error handling in the service layer, only to break the database constraints. Fix that, and the original service logic would be wrong again. Each attempt typically made the code more complex and moved further from the actual solution.</p><p>We developed a three-attempt pattern to contain these debugging sessions:</p><ol><li><strong>First three attempts</strong>: Let AI try to fix the test failures</li><li><strong>After three attempts</strong>: AI stops and asks for guidance</li><li><strong>Human step-in</strong>: Often involves showing Claude Code similar examples from the codebase</li></ol><p>This approach helps manage the debugging time, but these multi-layer scenarios remain where AI struggles most. The three-attempt limit prevents extended unproductive sessions, though complex debugging continues to be an area where the approach shows its limitations.</p><h3>6. Our Engineering Role Changed</h3><p>Beyond the technical challenges and metrics, something more fundamental shifted during our experiment. The most significant change was how we approached development work. Running multiple AI agents in parallel meant stepping back from writing code and focusing on coordination and specification.</p><p>To test whether parallel agents could compress development time, we needed to resist the urge to code ourselves. This shift felt counterintuitive at first — shouldn’t engineers be writing code? But the experiment required us to become orchestrators rather than implementers.</p><p>Our daily work has transformed. Instead of spending most of our time coding, we wrote detailed specifications in markdown files, managed multiple terminal sessions, and documented patterns for AI agents to follow. The implementation.md files became our primary tool for communicating with each agent — detailed enough for any session to pick up exactly where the previous one left off.</p><p>This approach had an unexpected benefit: when issues appeared across multiple work streams, like verbose variable naming or inconsistent error handling, we could update our style guide once, and all agents would immediately follow the new pattern. Rather than fixing code directly, we refined the instructions, keeping all parallel work streams consistent without becoming a bottleneck ourselves.</p><p>By the end of the experiment, our git history told the story: mostly markdown files documenting specifications, patterns, and feedback notes. The actual Go code came from AI while we focused on aligning multiple work streams and moving forward. This role transformation was essential to achieving the parallel execution we were testing.</p><h3>7. Conclusion</h3><p>Looking back on our two-week trial, we observed ~40% higher PR throughput compared to a recent baseline period while maintaining comparable review and CI gates. Results are preliminary; longer validation studies are underway. But what surprised us most wasn’t the throughput improvement — it was how different the work felt.</p><p>The challenges we encountered taught us as much as the successes, shaping our understanding of what works when orchestrating multiple AI agents and revealing areas where this approach shows its limitations. Perhaps most significantly, the trial required us to rethink our role as engineers — instead of writing code, we found ourselves writing specifications and refining patterns that AI could follow consistently.</p><p>The five-element methodology we developed worked for our specific Rails-to-Go migration context, but the larger question isn’t whether this approach can work in isolated trials — it’s whether it enables sustained development speed while maintaining quality standards over months. That assessment requires time, and the industry-standard DORA metrics would help measure both speed and quality dimensions comprehensively.</p><p>We’re continuing to experiment with these ideas, refining both the methodology and our understanding of its limitations. We’d love to hear what works — and what doesn’t — as more teams explore similar approaches to parallel AI development.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=64aa33ab64e6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/spec-first-parallel-ai-development-early-lessons-from-a-two-week-trial-64aa33ab64e6">Spec-First Parallel AI Development: Early Lessons from a Two-Week Trial</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>