GitHub
Artificial intelligence accelerates enterprise software delivery only when companies overhaul handoff-heavy workflows instead of bolting autonomous tools onto legacy processes.
AI-assisted summary of 17 agents, one SDLC: How Levi Strauss reimagined development on GitHub — original source. Check the original for full context.
Source published:
Key ideas
- Levi Strauss & Co. redesigned its software development lifecycle around 17 specialized AI agents running on GitHub Copilot Cloud Agent and Model Context Protocol (MCP), cutting mobile application build time by 72% from 9 months to 2.5 months. (0:03)
- The operational framework establishes strict human gates where AI executes tasks while humans retain decision authority, reducing human involvement to just two primary approval checkpoints: spec review and final production merge. (6:47)
- Rather than causing an initial productivity dip, squad throughput rose 51% immediately alongside a 54% gain in test pass rates, while AI-assisted pull requests jumped from 26% to 69%. (25:36)
- To prevent merge conflicts caused by agents writing concurrently to pull requests, Levi Strauss decoupled the pipeline so specialized agents leave comments in parallel while a single downstream helper agent synthesizes fixes into a unified commit. (27:30)
Detailed notes
## Background Published on YouTube by GitHub on November 8, 2026, this GitHub Universe 2026 session features Jenny Patchen, Senior Director of Shared Platforms & Services at Levi Strauss & Co. The presentation details how Levi Strauss built an enterprise multi-agent software development lifecycle on GitHub Copilot's custom agents platform, employing 17 specialized agents connected via Model Context Protocol (MCP) to streamline everything from requirements and spec generation to automated testing, security, and deployment.
## TL;DR To overhaul its retail 'Back Pocket' mobile application development, Levi Strauss & Co. re-architected its traditional four-phase, handoff-heavy SDLC into an outcome-oriented system powered by 17 specialized AI agents and GitHub Copilot. Guided by the principle that humans make decisions while agents execute, the architecture routes tasks like EARS spec drafting, regression testing, and security scanning through single-purpose agents linked via MCP, reducing human intervention down to two critical pull request approval gates. The initiative cut application build time by 72%—dropping delivery from nine months to just 2.5 months—while increasing squad throughput by 51% and test pass rates by 54%. Beyond the technical implementation, the transformation required intentional change management, shifting senior developers from hand-crafting code to spec-driven review and proving that adopting AI requires redesigning the factory floor rather than simply swapping in a new motor.
## Atmosphere & style Jenny Patchen delivers a polished, pragmatic enterprise keynote that balances sweeping economic analogies with concrete, battle-tested engineering blueprints. The tone is refreshingly grounded, trading speculative AI hype for candid discussions about sticky-note friction maps, merge conflict bottlenecks, and the psychological hurdles experienced by senior engineers unlearning legacy habits. Watching the presentation feels like sitting through an empowering masterclass in organizational change, marked by clear architectural diagrams, measured confidence, and an overarching respect for developer craftsmanship.
## Bulletin - [00:03](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=3s) Levi Strauss & Co. redesigned its software development lifecycle around 17 specialized AI agents running on GitHub Copilot Cloud Agent and Model Context Protocol (MCP), cutting mobile application build time by 72% from 9 months to 2.5 months. - [06:47](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=407s) The operational framework establishes strict human gates where AI executes tasks while humans retain decision authority, reducing human involvement to just two primary approval checkpoints: spec review and final production merge. - [25:36](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1536s) Rather than causing an initial productivity dip, squad throughput rose 51% immediately alongside a 54% gain in test pass rates, while AI-assisted pull requests jumped from 26% to 69%. - [27:30](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1650s) To prevent merge conflicts caused by agents writing concurrently to pull requests, Levi Strauss decoupled the pipeline so specialized agents leave comments in parallel while a single downstream helper agent synthesizes fixes into a unified commit.
## Key takeaways - [00:03](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=3s) Treating AI adoption like electrifying a factory floor requires redesigning underlying workflows rather than dropping a new motor into legacy, friction-heavy processes. - [04:22](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=262s) Analyzing the legacy Back Pocket application lifecycle revealed that lead time was dominated by human waiting queues and handoffs, notably 2 to 4 weeks drafting stories and 3 weeks of manual QA. - [06:47](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=407s) The team applied a modified McKinsey task framework that strictly delineates 'AI Does', 'Human Does', and 'Human Decides', ensuring accountability stays with human engineers. - [06:47](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=407s) Every agent definition requires five foundational parameters upfront: trigger, input, action, output, and the explicit human handoff gate. - [09:46](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=586s) The architecture keeps agents in existing developer interfaces (VS Code, GitHub.com, Copilot CLI) and decouples external tool integrations through Model Context Protocol (MCP). - [09:46](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=586s) Agent configurations are managed as plain Markdown files in .github/agents/ with YAML frontmatter, subjecting agent prompts and permissions to standard PR review and audit workflows. - [13:23](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=803s) Requirements engineering relies on EARS syntax, and agents are instructed to stop and ask clarifying questions early whenever ambiguities arise to prevent downstream rework. - [13:23](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=803s) Automated quality gates execute in a strict sequential chain—tests, accessibility, performance, code review, and security last—ensuring security scans all prior agent adjustments. - [15:33](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=933s) Agent actions on pull requests generate explicit labeled commits and aggregated executive summaries so developers retain full visibility without parsing fragmented diffs. - [16:27](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=987s) Enterprise standards are packaged into 10 starter kits across 9 languages, backed by Copilot Agentic Auto-Fix to automatically resolve continuous integration failures. - [19:46](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1186s) An internal developer marketplace centralizes 24 custom agents, 19 skills, 15 MCP servers, and prompt libraries with community ratings to maximize organizational reuse. - [20:31](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1231s) Organizational change management was addressed via dedicated AI Principal coaching, live training on real production code, and open office hours rather than toy sandboxes. - [23:31](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1411s) Senior, high-performing engineers often faced the greatest learning curves because shifting to spec-driven development required unlearning deeply ingrained manual coding habits. - [25:36](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1536s) Team standups shifted away from manual status updates toward high-bandwidth discussions centered on architecture, critical decisions, and unblocking exceptions. - [27:30](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1650s) Simultaneous parallel agent commits initially triggered severe branch merge conflicts, prompting an architectural pivot to parallel commenting resolved by a single helper agent. - [28:31](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1711s) Levi Strauss compressed its initial 3-day squad onboarding curriculum down to a 3-hour agile format, providing a scalable model to onboard future teams rapidly.
## Detailed walkthrough ### [00:03](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=3s) Reimagining the Factory Floor: From Steam Motors to Multi-Agent Workflows
Jenny Patchen, Senior Director of Shared Platforms & Services at Levi Strauss & Co., opens her talk with an economic history lesson drawn from economist Paul David. When electricity was first introduced to factories, factory owners simply removed the central steam engine and installed an electric motor in its place, leaving the assembly lines, workflows, and spatial floor plans entirely unchanged. As a result, factory productivity remained stagnant for decades. Real productivity surged only when manufacturers completely rethought factory architecture to exploit the distributed nature of electric power. Jenny draws a direct parallel to the contemporary adoption of artificial intelligence: “And I think that's where we are today with agents. It's the same old factory and a new motor.”
At Levi Strauss & Co., the goal was to avoid that trap by reimagining the entire software development lifecycle (SDLC) on GitHub. The test ground for this initiative was "Back Pocket," the proprietary mobile application used by store stylists on retail floors to assist shoppers—offering critical retail capabilities such as "Endless Aisle" to find inventory across regions. Jenny displays a current-state journey map covered in pink and yellow sticky notes, representing deep organizational friction and pain points across the legacy SDLC. The end result of the transformation was the release of the rewritten Back Pocket app to stylists and fans across Southeast Asia.
- The legacy Back Pocket application took nine full months to build. - The re-architected SDLC enabled the new application to launch in just 2.5 months—a 72% reduction in build time. - The project was not an academic exercise in process redesign; it was driven by delivering real utility to stylists and retail fans in months rather than years.
[02:59](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=179s) Defining Success: Working Backwards from Business Outcomes
To transform the process, the team avoided jumping straight into prompt engineering and instead worked backward from three foundational definitions of success:
1. **Faster Speed to Value:** Eliminating procedural drag and addressing the friction documented on the workshop sticky notes so cross-functional work could ship rapidly without burning out developers. 2. **Higher Quality through Spec-Driven Development:** Introducing automated testing earlier in the lifecycle and leveraging spec-driven development to push ambiguous architecture and design questions far to the left, which directly curtailed production regressions and expensive downstream rework. 3. **Standards Built-In, Not Bolted-On:** The engineering leadership had spent extensive effort codifying best-practice standards for observability, security, and accessibility. However, those standards were historically vulnerable to human omission. As Jenny notes, “We wanted to make the right path, the easy path, and to streamline that for our team.”
[04:22](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=262s) Mapping the Legacy SDLC and Identifying the Long Poles
Before writing a single line of agent configuration, the cross-functional group—including representatives from Product, Engineering, Developer Velocity, Quality Engineering, and the company's AI Principal—convened for an intensive three-day, in-person offsite. Laptops remained closed while the team mapped out workflows on paper. Day one was dedicated to laying out the warts-and-all current state; day two focused on architecting the future-state vision and target metrics; and day three isolated the technical and operational enablers required to execute the vision.
```mermaid flowchart LR accTitle: Legacy Back Pocket SDLC Flow accDescr: The four sequential phases of the legacy SDLC displaying handoffs and major delays across six roles.
subgraph P1["Plan Phase"] A["Write User Story"] end subgraph P2["Build Phase"] B["Feature Development"] end subgraph P3["Verify Phase"] C["Manual QA & Regression"] end subgraph P4["Release Phase"] D["Production Deployment"] end
A -->|"2 to 4 weeks (or months)"| B B -->|"Handoff delays"| C C -->|"3-week bottleneck"| D ```
When redrawn, the legacy delivery pipeline spanned four rigid phases—Plan, Build, Verify, and Release—encumbered by 12 distinct handoffs across six functional roles. The delivery pipeline suffered from two massive "long poles in the tent": - **Writing User Stories:** Drafting user stories regularly dragged out between 2 and 4 weeks, and sometimes stretched into months due to complex cross-functional coordination and misaligned organizational dependencies. - **QA and Regression:** The quality assurance phase required three full weeks at the very tail end of delivery, creating an acute bottleneck that triggered extensive late-stage rework loops.
Analyzing the handoffs revealed that most of the lead time consisted of human beings waiting on other human beings. Jenny highlights the shift in mindset that resulted from this finding: “And so this changed the question we asked ourselves, which then wasn't how do we make humans work faster? But instead, how do we stop the waiting?”
[06:47](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=407s) Redesigning the Operating Model: Humans Decide, Agents Execute
To structure the division of labor between generative models and people, the team adopted and altered a McKinsey task-mapping framework. Every legacy SDLC task was reframed as an outcome rather than a chore. For instance, rather than tracking "writes requirements," the target outcome was designated as "requirements are clear, cross-functional, and aligned."
The team separated work across four explicit operational columns: - **AI Does:** Tasks such as drafting, synthesizing, implementing code, and ongoing monitoring—high-toil activities that require speed and processing power rather than nuanced human judgment. - **Human Does:** Tasks requiring context injection, taste, cross-stakeholder alignment, and creative domain expertise. - **Human Decides:** Approving, rejecting, prioritizing, or escalating decisions.
Jenny stresses the architectural and cultural importance of separating human actions from human decisions: “And this was one of our most important decisions was splitting human decides from human does for the reason that it always kept the accountability with the human.”
| Lifecycle Domain | Desired Outcome | AI Does | Human Does | Human Decides | |:--- |:--- |:--- |:--- |:--- | | **Requirements** | Requirements are clear, cross-functional, and aligned | Drafts testable requirements; captures dependencies; flags ambiguities | Provides raw context and initial business ideas; audits agent drafts | Prioritizes feature backlog; formally approves final requirements |
To implement any specific agent, the team mandated that five operational parameters be defined up front: 1. **Trigger:** The event initiating the workflow (e.g., a feature request arrives). 2. **Input:** The source artifacts (e.g., the Jira ticket details and standardized Levi Strauss spec templates). 3. **Action:** The operational mandate (e.g., drafts testable technical requirements and explicitly interrogates ambiguous criteria). 4. **Output:** The artifact produced (e.g., clear, testable technical requirements ready for build execution). 5. **Handoff:** The human gate (e.g., an engineer or product owner merges the spec-approval pull request).
[09:46](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=586s) The 17-Agent Enterprise Platform Architecture
Jenny presents the technical architecture that underpins this SDLC. The strategy relied strictly on meeting developers in their existing daily environments—such as GitHub.com, VS Code, and the Copilot CLI—rather than introducing fragmented secondary portals.
```mermaid flowchart TD accTitle: Levi Strauss Multi-Agent SDLC Architecture accDescr: Architecture diagram showing developer entrypoints, the central Copilot orchestration engine, 17 specialist agents, and external systems via MCP.
subgraph UI["Developer Interfaces"] IDE["VS Code / GitHub.com / Copilot CLI"] end
subgraph CORE["Execution & Orchestration Engine"] ORCH["Orchestration Agent"] CCA["Copilot Cloud Agent"] STANDARDS["Shared Skills & Enterprise Standards"] ORCH --- CCA CCA --- STANDARDS end
subgraph AGENTS["17 Specialist Agents"] REQ["Requirements Agent"] OBS["Observability Agent"] TEST["Testing Agent"] OTHER["14 Security, Accessibility, & Other Agents"] end
subgraph TOOLS["MCP Server Integrations"] JIRA["Jira / Confluence"] NR["New Relic"] PW["Playwright"] MISC["Figma / GitHub / Context7"] end
IDE --> ORCH ORCH --> REQ & OBS & TEST & OTHER REQ <-->|"MCP"| JIRA OBS <-->|"MCP"| NR TEST <-->|"MCP"| PW OTHER <-->|"MCP"| MISC ```
The system comprises 17 specialized AI agents routed by a central orchestration agent. Rather than creating generic assistants, Levi Strauss created single-purpose agents: - The **Requirements Agent** extracts Jira context to generate comprehensive technical specs. - The **Observability Agent** verifies and injects application instrumentation, querying telemetry via New Relic. - The **Testing Agent** authors, runs, and updates browser-level regression suites using Playwright. - **14 Additional Specialized Agents** manage accessibility validations, automated security analysis, and domain-specific code hygiene.
All agents run on top of GitHub Copilot Cloud Agent as their execution engine, decoupling integrations via the Model Context Protocol (MCP). Jenny emphasizes the enterprise maintainability of this approach: “And importantly, when these systems change out, we change the connection. We don't change the agent.”
Under the hood, each agent is defined as a simple Markdown configuration file stored inside the root `.github/agents/` folder at the organizational level. This makes all 17 agents instantly available across every repository in the company with zero setup required by developers. Each file contains YAML frontmatter defining metadata and MCP tool declarations (such as Jira or Confluence), followed by clear plain-text natural language instructions detailing what the agent is authorized to do and what it is explicitly barred from doing.
Changes to agent definitions are treated identical to production software changes: they require a pull request, code review, automated testing, versioning, and an audit trail. Because the definitions are plain Markdown, any developer, QA engineer, or product manager can inspect the system prompts and submit PRs to improve agent behavior.
[13:23](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=803s) The Multi-Agent Workflow and Human Gates
In Jenny Patchen's visual diagram of the software development lifecycle, human touchpoints are highlighted in white, while incoming signals appear in orange. The process initiates with the requirements agent, which kicks off the requirements specification and test planning using EARS (Easy Approach to Requirements Syntax), a structured syntax designed to keep automated tests clean and unambiguous. Patchen notes that from day one, Levi Strauss & Co. actively instructed their agents to halt and raise questions whenever specifications were unclear: “And it's one thing I also want to call out here is we really encouraged our agents to ask when anything was ambiguous, and they needed further guidance because it stopped rework later in the process.”
Once requirements take shape, the specification is submitted as a pull request for human sign-off. As soon as the engineer approves and merges the spec PR, the GitHub Copilot cloud agent steps in to spin up the actual build and open a subsequent pull request. Downstream specialists are brought into the loop—though Levi Strauss does not execute all 17 specialists on every single run; they are summoned only when relevant. Following the specialists, the automated quality gates fire in a non-negotiable sequence: testing, accessibility, performance, code review, and lastly, security. Security intentionally runs at the very end of this chain so that it evaluates every single automated modification made by preceding agents.
Next, an observability agent inspects the pull request to verify that all necessary tracing is added for New Relic telemetry. Once ready for rollout, an optional deployment agent provides recommendations on the safest release strategy. Only then does the flow circle back to a person: the engineer inspects the final output and merges to production, backed by continuous New Relic telemetry in runtime. Patchen underscores how narrow the human surface area has become: “And what I really want to call out here is that, you see, there's only two aspects where the human is really involved. Everything else is running by the agent's end to end.”
```mermaid flowchart TD accTitle: Multi-Agent SDLC Workflow at Levi Strauss accDescr: An end-to-end SDLC showing automated agents executing between two strict human review checkpoints.
subgraph Phase1["Phase 1: Requirements & Spec Gate"] Req["Requirements Agent<br/>(EARS Syntax)"] -->|"Spec PR"| HGate1{"Human Gate 1:<br/>Approve Spec PR"} end
subgraph Phase2["Phase 2: Build & Specialist Work"] HGate1 -->|"Merged"| CopilotBuild["Copilot Cloud Agent<br/>(Build & Opens PR)"] CopilotBuild --> Specialists["Optional Specialists<br/>(Up to 17 Agents)"] end
subgraph Phase3["Phase 3: Sequential Quality Gates"] Specialists --> QG1["1. Tests"] QG1 --> QG2["2. Accessibility"] QG2 --> QG3["3. Performance"] QG3 --> QG4["4. Code Review"] QG4 --> QG5["5. Security (Always Last)"] end
subgraph Phase4["Phase 4: Telemetry & Production Gate"] QG5 --> ObsAgent["Observability Agent<br/>(New Relic)"] ObsAgent --> DeployAgent["Optional Deployment Agent<br/>(Recommendations)"] DeployAgent --> HGate2{"Human Gate 2:<br/>Review & Merge PR"} HGate2 -->|"Deploy"| Prod["Production Run<br/>(Continuous Telemetry)"] end ```
[15:33](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=933s) Pull Request Experience: Labeled Commits and Summaries
Reviewing agent-generated work on GitHub is designed to be frictionless for the developer. Walking through a real commit history from a developer portal migration to Next.js, Patchen highlights how the initial build and execution plan receive clear, labeled commit updates from each functional agent—including testing, code review, accessibility, and security fixes. Rather than forcing engineers to parse raw diffs across multiple commits, the workflow collates their findings into an executive overview:
- **Labeled Commits:** Each agent writes fixes straight back into the branch with an explicit label indicating what changed and which agent executed it. - **Consolidated Summaries:** The platform aggregates individual agent findings into a single unified summary inside the PR description so developers immediately grasp every automated adjustment. - **Driver's Seat Philosophy:** The human developer retains final authority to approve or reject the final bundle before anything is merged.
[16:27](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=987s) Enforcing Standards: Security, Accessibility, Performance, and Starter Kits
Levi Strauss translates organizational standards into programmatic agent rules across four key disciplines. The security agent audits dependencies and runs secret detection aligned with OWASP guidelines and CVE databases, resolving vulnerabilities based on calculated severity. Accessibility compliance targets WCAG 2.2 AA standards, validated directly inside real headless browsers via Playwright and remediated in-branch. The performance agent also leverages Playwright to evaluate Core Web Vitals, operating under a strict engineering rule: performance must always be measured directly rather than estimated before remediation occurs. Finally, the observability agent ensures applications never ship without essential runtime instrumentation.
To scale these disciplines across the enterprise, Levi Strauss runs an agent strategy side-by-side with a standardized repository strategy. They built 10 organization-wide repo starter kits—covering 9 of their most common engineering languages from TypeScript to Swift—embedding CI/CD best practices, runbooks, documentation, `agents.md` context files, and Copilot instruction files from day one. High-velocity development is backed by strict automated controls:
> “And you can only go as fast as you have good brakes. And that's why we've built robust gates in our CI.”
These continuous integration checks enforce dependency reviews, coverage metrics, and New Relic preflight validation on every pull request. If an error surfaces during CI, Copilot Agentic Auto-Fix investigates the failure, devises a resolution, and submits a fix back to the pull request for engineer approval. For legacy repositories, the same tooling operates retroactively: an agent analyzes the existing codebase, contrasts it against the official starter kit templates, pinpoints structural deficiencies, and generates remediation pull requests for engineering teams to inspect.
[19:46](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1186s) The Internal Marketplace: Custom Agents, Skills, and MCP Servers
To avoid duplicate engineering and democratize tooling, Levi Strauss provides an internal marketplace structured into four distinct categories: Custom Agents, Skills, Prompts, and Model Context Protocol (MCP) servers. Exposed directly through GitHub and VS Code, the marketplace operates as an internal catalog where teams can consume, rate, and review tools with single-click availability.
| Shelf Category | Total Available | Purpose and Highlights | |:--- |:--- |:--- | | **Custom Agents** | 24 agents | Specialized role-based bots covering functional domains across the SDLC. | | **Skills** | 19 skills | Modular abilities and actions leveraged by Copilot agents during task execution. | | **MCP Servers** | 15 servers | Standardized Model Context Protocol connections into enterprise systems like Jira and New Relic. | | **Prompts** | Curated catalog | Reusable prompt templates tested and validated by internal engineering teams. |
Engineers leave community reviews and star ratings on every asset, driving organizational reuse, standardizing delivery baselines, and shortening time to value for downstream teams.
[20:31](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1231s) Change Management and AI Adoption Strategies
Patchen emphasizes that engineering the technology was simple compared to the human side of the rollout: “The tooling was really the easy part and the change management was the heavy lift in terms of the work.” When roles undergo seismic shifts, team members inevitably experience anxiety about their future responsibilities. To address these concerns and cultivate trust, Levi Strauss designed a multi-tier enablement program:
- **Industry Research Pre-reads:** Prior to day one of technical workshops, developers received curated reading materials featuring enterprise blueprints from leading engineering organizations alongside research from Gartner and McKinsey, encouraging them to pursue systemic transformation over small incremental gains. - **Embedded Principal AI Engineer:** A senior engineer functioned as a dedicated player-coach, embedding into team standups, hanging out in daily chat channels, running coaching sessions, and troubleshooting blockers shoulder-to-shoulder with developers. - **Hands-on Learning with Production Code:** Engineers trained directly on their active production repositories rather than abstract toy exercises in synthetic sandboxes. - **Developer Velocity Office Hours:** Open weekly forums established a safe space for developers to ask questions, explore newly released features, and observe peer demonstrations. - **Dedicated AI Hackathons:** A company-wide competition mandated AI utilization for all participants, preceded by technical upskilling; several solutions built during the event successfully shipped to production.
[23:31](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1411s) The Four Operating Rules and Managing Senior Engineering Friction
To settle technical debates and guide day-to-day work, Levi Strauss established four memorable operating tenets:
1. **Humans as judgment, agents on execution:** Developers handle ambiguous architectural decisions, taste, and critical thinking, while delegating routine, repetitive labor to agents. 2. **Context lives where agents can see it:** Repositories and tickets are durable storage; conversational chat is ephemeral. While chat will eventually fold into long-term context, the current framework relies strictly on tracked artifacts. 3. **The same bar for agents and humans:** Automated agents and human contributors pass through the exact same quality gates, code reviews, and testing thresholds. 4. **Auditable always:** Every autonomous agent action, commit, and human override is captured in persistent audit logs.
Adopting this mental model proved especially challenging for seasoned contributors. Citing a Korn Ferry white paper, Patchen observed that senior, high-performing engineers often faced the steepest learning curve when transitioning to AI-assisted workflows:
> “Because if you've been successful your entire career with a set of skills, it becomes very hard to walk away from those skills which have continually given you that success and set you ahead in your organization.”
Unlearning traditional coding habits required teams to deliberately build new rituals around spec-driven development and train developers to critically evaluate agent output rather than hand-crafting every implementation detail from scratch.
[25:36](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1536s) Measuring Impact: Throughput, Quality, and Adoption Metrics
Jenny Patchen breaks down the cultural and quantitative transformations within the engineering squads following the rollout of the multi-agent system. The day-to-day rhythm of team collaboration shifted noticeably: standup meetings were fundamentally altered so that they no longer centered on manual status reports. Instead, standups turned into high-bandwidth discussions focusing strictly on open architectural debates, active decision-making, and addressing exceptions. This shift allowed engineers to spend less time relaying updates and more time solving structural blockers together.
The initial rollout defied conventional engineering expectations regarding productivity dips during major organizational changes. Leadership originally anticipated that squad throughput would decline early on, recognizing that adapting to an entirely new multi-agent paradigm was a massive transition requiring runway for teams to process. Instead, throughput jumped immediately by 51%. Concurrently, test pass rates improved by 54%, demonstrating that automated agents were elevating baseline software quality rather than trading off craftsmanship for sheer output. As Jenny Patchen explains: “And in particular, you can think of velocity and quality often as a paradox. Where velocity declines and quality improves or quality declines and velocity improves. It's really irregular that both could increase together.”
Patchen addresses the common skepticism that higher throughput metrics can simply reflect generative agents producing bloated code for the sake of activity rather than real business value. She highlights that Levi Strauss & Co. delivered the new minimum viable product (MVP) substantially faster than the legacy MVP benchmark, validating that productivity matched concrete delivery outcomes. Developer adoption surged in tandem: while squads started with 26% of pull requests assisted by AI—having already explored early generative tools—that number rapidly surged to 69% over a concise observation window, with the ongoing trajectory moving toward full 100% adoption across future initiatives.
- **51% throughput improvement**: Squad velocity increased immediately out of the gate despite initial expectations of an adaptation-related productivity dip. - **54% automated pass rate**: Test suite success rates rose simultaneously, breaking the traditional velocity-versus-quality paradox. - **69% AI-assisted PR adoption**: Increased from a 26% baseline at the start of the engagement, with ongoing progress aimed at 100%. - **Outcome validation**: Verified that the accelerated pace represented actual product delivery of the rebuilt Back Pocket app, far outpacing the legacy release cycle.
---
[27:30](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1650s) Architectural Evolution: Eliminating Merge Conflicts and Agent Runaway
Reflecting on technical lessons learned, Patchen reveals how the team continuously iterated on their pull request review pipeline. The initial architectural ambition was to execute all automated PR agents in parallel to maximize evaluation speed. However, multiple autonomous agents independently updating files simultaneously generated persistent merge conflicts across branches. The team initially responded by pulling back from concurrent writes to manage branch stability, but quickly devised a cleaner, decoupled architecture.
In the modernized setup, the specialized verification agents—handling domains like security, accessibility, and code standards—run concurrently but strictly leave review comments instead of committing direct modifications. A dedicated downstream "helper agent" then ingests all generated review comments at the end of the pipeline, reconciles the feedback holistically, and applies a unified set of code fixes back to the branch. This eliminated merge conflicts while retaining the operational speed of independent parallel evaluations.
Patchen also highlights the necessity of designing systems where ambiguity surfaces early. Because autonomous agents frequently rush forward with complete confidence and generate outputs misaligned with human developer intent, the framework was architected to force early clarity checks rather than permitting unsupervised completion of ambiguous tasks.
```mermaid flowchart TD accTitle: Multi-Agent PR Review and Resolution Flow accDescr: Independent review agents comment on pull requests in parallel, and a downstream helper agent reconciles comments into a single unified commit.
subgraph Evaluation ["Parallel Review Phase"] A["Pull Request Branch"] --> B["Security Agent"] A --> C["Accessibility Agent"] A --> D["Quality & Spec Agent"] end
subgraph Feedback ["Feedback Aggregation"] B -->|"posts inline comments"| E["PR Comment Stream"] C -->|"posts inline comments"| E D -->|"posts inline comments"| E end
subgraph Resolution ["Automated Remediation"] E --> F["Helper Agent"] F -->|"resolves feedback & creates single commit"| G["Clean PR Branch Updated"] end ```
---
[28:31](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1711s) Scaling Adoption and the Philosophy of Process Reimagination
Scaling the agentic framework required streamlining the intensive onboarding curriculum used to train engineering squads. The inaugural onboarding workshop represented an enormous upfront investment: three solid days in a dedicated room, backed by an equivalent number of hours in pre-workshop preparation and significant post-session follow-through. While this hands-on immersion produced strong team results, it was not sustainable to scale across the broader enterprise.
Levi Strauss & Co. re-engineered the onboarding process into an agile format. Subsequent squad onboardings condensed the curriculum progressively down to as few as three hours, while maintaining the same positive behavioral and technical outcomes. This compressed format established a scalable playbook, allowing upcoming squads to transition into the agentic SDLC with far lower friction and quicker time-to-value.
Jenny Patchen ties the technical architecture back to the original mission of rebuilding the Back Pocket mobile retail platform. The project began with a legacy value stream map overwhelmed by systemic handoffs and operational friction, and culminated in a completely rebuilt, modern application deploying directly into Southeast Asia markets, achieving an overall 72% end-to-end process improvement.
Patchen concludes with a core philosophical warning for any organization looking to implement AI development agents: “Reimagine your process first. Don't put the new motor in the old factory.” Pointing back to the company’s history, she reflects on the parallel between physical craftsmanship and digital engineering: “In 1873, we reimagined workwear. This year, we reimagined software with our amazing engineering team at LS&Co.”
- **Workshop compression**: Reduced squad onboarding duration from a 3-day intensive workshop down to a streamlined 3-hour session without degrading implementation outcomes. - **Back Pocket deployment**: The transformed software delivery process powered the successful release of the new retail app in Southeast Asia. - **72% end-to-end efficiency improvement**: Achieved across the entire software delivery lifecycle from concept to release. - **Core implementation principle**: Automated multi-agent platforms require redesigning underlying operational processes rather than superimposing AI tooling onto legacy development habits.
## Notable quotes > [28:31](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1711s) Reimagine your process first. Don't put the new motor in the old factory. — Jenny Patchen
> [20:31](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1231s) The tooling was really the easy part and the change management was the heavy lift in terms of the work. — Jenny Patchen
> [16:27](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=987s) And you can only go as fast as you have good brakes. And that's why we've built robust gates in our CI. — Jenny Patchen
> [23:31](https://www.youtube.com/watch?v=-GpxKKgoWWg&t=1411s) If you've been successful your entire career with a set of skills, it becomes very hard to walk away from those skills which have continually given you that success and set you ahead in your organization. — Jenny Patchen
## Mentioned Jenny Patchen, Paul David, Levi Strauss & Co., GitHub, GitHub Copilot, GitHub Copilot Cloud Agent, Copilot CLI, VS Code, Back Pocket, Model Context Protocol (MCP), Jira, Confluence, New Relic, Playwright, Figma, Next.js, McKinsey, Gartner, Korn Ferry, OWASP, EARS
## Video description Levi Strauss & Co. built an enterprise multi-agent software development lifecycle on GitHub Copilot's custom agents platform. In this GitHub Universe 2026 session, Jenny Patchen, Sr. Director at Levi Strauss & Co., reveals how seventeen specialized AI agents handle requirements, spec generation, automated testing, security scanning, accessibility validation, and deployment connected to Jira, Confluence, and New Relic through Model Context Protocol (MCP). Every pull request is reviewed by 5 to 11 independent agents that automatically fix issues and commit back to the branch, while retaining strict human approval gates. Explore the enterprise architecture, lessons learned, and practical blueprints for adopting a multi-agent SDLC across your organization.
Speaker: Jenny Patchen, Sr. Director, Shared Platforms & Services, Levi Strauss & Co.
Watch more videos from GitHub Universe 2026: https://www.youtube.com/watch?v=AArI948SDz8&list=PLENrlACZ7mnU
— CHAPTERS —
00:00 Introduction to Levi Strauss & Co. 01:14 Reimagining the back pocket app SDLC 02:59 Defining success and objectives 04:22 Rewiring the process 09:46 Enterprise multi-agent architecture 16:44 Enforcing standards and quality gates 19:47 Internal marketplace and reusability 20:32 Change management and team adoption 24:56 Measuring impact and lessons learned 29:11 Conclusion and future outlook
#GitHubUniverse #GitHubCopilot #AIAgents
Stay up-to-date on all things GitHub by connecting with us:
YouTube: https://gh.io/subgithub Blog: https://github.blog X: https://twitter.com/github LinkedIn: https://linkedin.com/company/github Insider newsletter: https://resources.github.com/newsletter/ Instagram: https://www.instagram.com/github TikTok: https://www.tiktok.com/@github
About GitHub It’s where over 180 million developers create, share, and ship the best code possible. It’s a place for anyone, from anywhere, to build anything—it’s where the world builds software. https://github.com
[Source](https://www.youtube.com/watch?v=-GpxKKgoWWg)