17 Agents, One SDLC: How Levi Strauss Rethought Development on GitHub
How Levi Strauss cut its app development cycle from nine months to two and a half: 17 AI agents, GitHub Copilot, and a new approach to SDLC.
The economist Paul David showed that when electricity first appeared in factories, productivity did not rise for a long time. Work processes stayed the same, and steam engines were simply replaced with electric ones. Significant productivity growth began only decades later, when processes were rebuilt to take advantage of what electricity could do. According to the speaker, the same thing is now happening with agents: the old factory has gotten a new engine.
Levi Strauss & Co. applied this approach to developing its own application. The company rebuilt its software development lifecycle (SDLC) on GitHub using 17 specialized agents.
Back Pocket App
Back Pocket is an app for store stylists. Staff use it on the sales floor to serve customers. The app supports features such as Endless Aisle.
The previous version of the app took nine months to build. The new version, launched in Southeast Asia, was built in two and a half months. This is a 72% reduction in time.
The goal of the changes was not to restructure the SDLC for its own sake. The company wanted stylists to get a better tool and customers to get better service, in months rather than years.
Goals and Priorities
The work began with defining success. From that definition, the team worked toward specific outcomes:
- Speed of value delivery. The team identified inefficiencies in the process. Despite high engagement and intense effort from employees, the process remained slow.
- Quality. The team expected to improve quality through automated testing. Spec-driven development was meant to reduce ambiguity in requirements by moving discussion to earlier stages. The team anticipated less impact on production and fewer rework cycles.
- Standards built into the process. The company had already defined standards for observability, accessibility, security, and other key areas. However, compliance depended on whether an engineer remembered them. The goal was to make the right path the easy path.
The work is described in three parts: restructuring the process, the platform, and bringing the two together.
Part 1. Restructuring the Process
Workshop
The team held a three-day workshop in one room. Key members of the product, development, developer velocity, and quality engineering teams took part. They worked mostly on paper, and laptops were barely used.
- Day 1. Analysis of the current state of the process.
- Day 2. Vision of the future state and target outcomes.
- Day 3. Identifying the conditions necessary for moving from the current state to the target state.
Current State of the Process
The process consisted of four stages: planning (plan), build (build), verification (verify), and release (release). It involved 12 handoffs of work between six roles. The cycle took months.
Two main bottlenecks stood out:
- Writing the user story. This stage took 2 to 4 weeks, and sometimes months. The timeline depended on dependencies and coordination between the company's departments.
- QE and regression testing. This stage took about three weeks and was always performed at the end of the process. It introduced friction and rework.
Most of the process was spent waiting. As a result, the question changed: the team stopped asking how to speed up people's work and started asking how to reduce waiting. In the team's view, agents could eliminate the waiting.
Role Distribution Model
The team's principle: agents begin execution, while people make decisions. The steps of the current process have been converted into outcomes. For example, the step "write requirements" corresponds to the outcome "requirements are clear, cross-functional, and agreed upon."
The model distributes work across three columns:
| Column | What it does | Examples |
|---|---|---|
| AI does | Tasks where agents are strongest | Synthesizes, drafts, implements, tracks |
| Human does | Tasks requiring critical thinking and judgment | Adds context, evaluates, manages stakeholders |
| Human decides | Decisions that carry accountability | Approves, rejects, escalates |
Separating "human decides" from "human does" became one of the most important decisions. It kept accountability with people. The human always remains in the driver's seat.
Example: Requirements Agent
Requirements must be clear, consistent, and cross-functional.
- The agent does: writes verifiable requirements and records dependencies.
- The human does: brings in ideas and reviews what the agent has written.
- The human decides: sets priorities and approves the requirements.
Based on this division of labor, the requirements agent was created.
Five Elements of an Agent
Before creating an agent, five elements must be defined:
- Trigger. For a requirements agent, this is the arrival of a feature request.
- Input. A request or ticket.
- Action. Writing verifiable requirements. When something is ambiguous, the agent asks questions.
- Output. Clear, verifiable requirements that the entire team can work from.
- Handoff. A human merges the PR with the approved specification.
Part 2. Platform
Architecture
The architecture is built around tools that engineers were already using: GitHub, Copilot CLI, and VS Code.
- Orchestrating agent distributes work among the team's agents.
- 17 specialized agents carry out tasks. Among them:
- a requirements agent, which creates specifications from tickets;
- an observability agent, which instruments code and conducts investigations;
- a testing agent, which writes and runs tests;
- 14 agents responsible for security, accessibility, and other areas.
- Tools. The requirements agent uses Jira as its work tracking system. The observability agent uses New Relic for telemetry and alerting. The testing agent uses Playwright for browser control. GitHub, Context7, and Figma are also used.
- Copilot cloud agent serves as the engine for all agents. Specialized agents are prompts that run on Copilot cloud agent.
- Skills provide reuse of standards and best practices.
When an external system is replaced, only the connection changes. The agent stays the same.
Agent as a Markdown File
An agent is a markdown file. It contains a short heading with the agent's description and instructions in plain text. Plain text allows any team member to read the instructions, understand them, and suggest improvements.
The file describes what the agent does, what it can do, and what it cannot do.
- All agents are stored in the
agentsfolder in a GitHub repository. At the organization level, they are automatically available in all repositories without additional configuration. - Agent changes go through a pull request, just like changes to data and code. Every change is reviewed, versioned, and audited.
- The same profile works on github.com, in Copilot CLI, the CLI, and VS Code.
- MCP servers are declared in the profile. The requirements agent has access to Jira and Confluence.
Agent Chain
Agents work more effectively as part of a chain. In the diagram, agents are highlighted in purple, people in white, and signals in orange.
The sequence works as follows:
- The requirements agent creates the specification and tests. The team uses EARS (Easy Approach to Requirements Syntax), a simple approach to requirements syntax that makes tests easier to write.
- A human approves the PR with the specification. After it is merged, the Copilot cloud agent runs the build and opens a PR.
- Specialists are brought in when needed. The team does not run all 17 specialists on every change.
- Quality gates always run, in a fixed order: Tests, Accessibility, Performance, Code review, Security. Security runs last, so it sees all changes made by the other agents.
- The observability agent instruments the code and checks the completeness of telemetry in New Relic.
- The deployment agent, which is optional, recommends a deployment approach to the engineer.
- A human reviews and merges the PR before the release to production. New Relic telemetry supports a continuous improvement cycle.
A human is involved at only two points: when approving the specification and when reviewing and merging the PR. All other stages are carried out end to end by agents.
The team also encouraged agents to ask questions when requirements are ambiguous. This reduces the amount of rework at later stages.
What the Reviewer Sees
The commit history example relates to the Next.js migration of the developer portal. It shows the initial build, the plan, and fixes from the security, accessibility, code review, and testing agents. Each fix is recorded in a separate labeled commit.
Engineers also receive a summary from each agent. This makes it quick to understand what changed.
Part 3. Standards
Standards are built into the agents rather than added after development.
- Security. The agent checks compliance with OWASP recommendations and common vulnerabilities and exposures (CVE). It performs audits and secret scanning. Identified issues are fixed according to their severity.
- Accessibility. The agent checks compliance with WCAG 2.2 Level AA. The check is performed in a real browser using Playwright, after which issues are fixed in the PR.
- Performance. The agent uses Playwright to measure performance against Core Web Vitals metrics. The team requires that metrics be measured, not estimated, before fixes are applied.
- Observability. The agent adds missing instrumentation.
Part 4. Starter Kits and Existing Repositories
The agent strategy is implemented in parallel with the repository strategy. Repository templates are starter kits available across the entire organization. They provide a unified baseline of engineering practice.
- There are 10 starter kits in total. Nine of them are associated with popular programming languages, such as TypeScript and Swift.
- The kits define practices for CI/CD, documentation, and runbooks from day one.
- The agents.md files and Copilot instructions allow agents to understand the repository as soon as it is connected.
Reliable controls ensure speed. The following checks are built into CI:
- dependency checking;
- tests;
- code coverage;
- a New Relic pre-check for every PR.
Copilot Agentic auto fix works as follows: when a CI process fails, the agent analyzes the problem, proposes a solution, and sends it to the engineer in a PR for approval.
Tools are also available for existing repositories. In this scenario, the agent assesses the repository, compares it with the templates, identifies gaps in the approach, prepares PRs, and routes them to the engineer for approval.
The goal of all this work is consistency, maintainability, reliable delivery, and readiness for AI-assisted development.
Part 5. Internal Marketplace
The internal marketplace contains four sections: custom agents, skills, prompts, and MCP servers. All engineers in the company have access to it.
- 24 agents.
- 19 skills.
- 15 MCP servers.
Engineers rate each item with stars and leave comments. The goal is reuse and accessibility of solutions across the organization and a shorter time to value. Items are available in VS Code and GitHub, and installation takes one click.
Part 6. Change Management
The tools turned out to be the simplest part of the work. The greatest effort went into change management. Employees feared changes to their roles and were uncertain about what was happening. The team worked on building trust in several ways.
- Pre-reading. Before the first day of the workshop, the team received a selection of materials on how leading organizations build an agentic SDLC. The materials included Gartner data and McKinsey research.
- Bold ideas. The materials were selected so that the team would think at scale and aim for transformation of the work, rather than small incremental improvements.
- Mentor engineer. A chief engineer, an AI expert, worked with the team throughout the process. He took part in daily stand-ups, was available in chat, ran coaching sessions, and helped with any tasks.
- Hands-on learning on their own code. Training was conducted on the team's real tasks rather than abstract sandbox examples.
- Office hours. Employees can ask questions in a safe environment. The team also shares information about new capabilities and demonstrates examples of other teams' work.
Additional measures were used to spread AI across the organization:
- Hackathon. It took place earlier this year and was dedicated exclusively to AI use cases. All participating teams were required to apply AI. Preliminary training was held before the competition. Some of the solutions developed have already moved into production.
- Conference. The company plans to hold an AI-focused conference next year.
Team Rules
- People are judgment agents, agents are execution agents. The team focuses on ambiguous tasks that require human judgment, experience, and taste. Routine tasks are handed off to agents.
- Context lives where agents can see it. The repository and the ticket are durable. Chat is not. The team acknowledges that chat will become part of the context, but at the time of working on Back Pocket, this had not happened yet. The team has set this as an expectation for employees.
- Same requirements for agents and people. Everything goes through the same quality checks.
- Audit. Every agent action and every human override of a decision is logged.
Results
Metrics the team measured:
- Throughput: up 51%. The team expected a decline, since restructuring the process for employees is significant and requires time to adapt.
- Pass rate: 54%. In the team's view, this metric confirms the improvement in quality.
- Share of AI-assisted PRs: 26% at the start and 69% by the end of the short period. The metric continues to grow. The goal is 100%.
The speaker noted that speed and quality are often treated as alternatives: when one rises, the other falls. She called the simultaneous growth of both unusual.
Throughput growth alone does not confirm that goals were achieved. The team proceeds from the premise that the application was released significantly faster: the MVP was built faster than the previous MVP.
According to a Korn Ferry study published about six months ago, the most effective team members experienced the greatest difficulties adopting AI. The experience that brought them success makes it hard to give up familiar skills. Therefore, the process required "unlearning" old practices. It also required establishing new rituals, such as specification-driven development and critical review of agents' outputs.
The format of the daily standup has changed. It is no longer devoted to status. Now it covers open questions, decisions, and exceptions.
What's Next
Previously Identified Limitations
The team expected that agents would work in parallel and each would complete its own task. In practice, parallel work caused merge conflicts. The team returned to an approach in which tasks are carried out sequentially.
Recently, the team changed its approach again. Each agent leaves comments, and a auxiliary agent at the end reviews all comments and makes corrections. This approach combines the efficiency and orderliness of the process and does not lead to merge conflicts.
The team also strives to identify ambiguity at early stages. Agents often act with complete confidence and produce a result that does not match the intent.
Shortening the Workshop
The first workshop took three days on site and required roughly the same number of hours in preparation. The result was successful, but expensive. The next step is to shorten it. The team ran the workshop with new teams in three hours and got good results. New teams are expected to onboard faster.
Summary
The starting point of the work was a current-state map with numerous problems. The end point was the new Back Pocket app, launched in Southeast Asia. The development timeline was shortened by 72%.
The speaker's main takeaway: before building agents, you should first restructure the process. A new engine should not be installed in an old factory.
