Levi Strauss & Co. rebuilt BackPocket, a mobile app that helps in-store stylists look up inventory and order out-of-stock items for shoppers, in two and a half months. The previous version of the same app had taken nine months to build and deploy. The apparel company attributes the 72 percent reduction not to any single AI tool but to a redesign of its entire software development life cycle (SDLC), the sequence of steps from a feature request to production code, around 17 specialized AI agents running on GitHub Copilot. A senior director of shared platforms and services at the company has laid out the full design, from the paper workshop where it started to the Markdown files that define each agent. The result is a practical blueprint for any engineering organization weighing how to bring agents into existing teams and tools.

Process first, then tools

The company frames its approach with an observation from economist Paul David about the Second Industrial Revolution. When factories first replaced steam engines with electric motors, productivity barely moved for years, because owners kept the same floor layouts and workflows. The gains arrived only when factories were rebuilt around what electricity made possible. The company argues that software teams are at the same point with AI agents: dropping agents into an unchanged development pipeline yields little, and the process redesign is the step most organizations skip.

So before writing any agent, the team defined what success meant in business terms:

  • Faster speed to value, measured as the time from an initial concept to a tool in a stylist's hands.
  • Higher quality, meaning fewer defects, less rework and fewer post-deployment bugs, with automated testing and spec-driven development as the main levers.
  • Standards built into the platform rather than bolted on afterward. The company already had enterprise definitions for observability, accessibility and security by design, but it concluded that standards fail when they depend on developer memory. The correct path had to become the easiest, automated path.

Mapping 12 handoffs on paper

A cross-functional group from product management, software engineering, developer velocity, quality engineering and AI architecture spent three days in one room with laptops closed, working on paper and whiteboards. Day one mapped the current process, day two defined the future state and target outcomes, and day three identified the technical enablers needed to connect the two.

The current-state map showed four stages: Plan (prioritize, write user stories, break them down, size and assess dependencies), Build (write code and unit tests, open branches and pull requests, review, build and merge), Verify (QA and regression, acceptance) and Release (retail pilot, retail rollout). Across those stages the team counted 12 handoffs among six roles. Two bottlenecks dominated: writing user stories took two to four weeks and sometimes months because of cross-functional alignment, and QA regression testing consistently consumed three weeks at the very end of every cycle.

That finding changed the leadership question. Instead of asking how to make people code faster, the team asked how to eliminate waiting time between handoffs using agents.

Deciding what agents do and what people decide

Team moves index cards across a four-column whiteboard dividing outcomes, AI tasks, human tasks and human decisions

▲ Four-part grid separating AI execution from human decisions

On day two the team adopted a simple operating rule: agents take on execution, humans make the final decisions. To apply it, they built a four-column grid modeled on a McKinsey-style framework: Outcomes, AI Does, Human Does and Human Decides.

Every legacy step was rewritten as an outcome. "Write requirements" became "requirements are clear, aligned and cross-functional." Then each outcome was split across the remaining columns:

Column What goes here
AI Does Synthesis, initial drafting, implementation, continuous monitoring
Human Does Providing context, exercising discernment, evaluating nuance, managing stakeholder communication
Human Decides Approving, rejecting or escalating agent proposals

Separating "Human Does" from "Human Decides" is deliberate. The company sees it as the mechanism that keeps people accountable and in control even as agents do most of the typing.

Each grid cell then became an agent card with five parameters: Trigger, Input, Action, Output and Handoff. For the Requirements Agent, the trigger is a new feature request; the input is the raw ticket, customer request or spec template; the action is drafting testable requirements and asking stakeholders questions whenever the agent detects gaps or ambiguity; the output is a clean set of testable requirements; and the handoff is a human reviewer confirming the spec and merging a spec-approval pull request.

One orchestrator, 17 specialists and the tools teams already use

The platform plugs into the places developers already work: GitHub.com, GitHub Copilot CLI and Visual Studio Code. An orchestration agent receives requests from those surfaces and routes each one to the appropriate specialist. The 17 specialists include a Requirements Agent that drafts specs from tickets, an Observability Agent that instruments telemetry and investigates issues, a Testing Agent that writes and runs test suites, and 14 others covering domains such as application security and digital accessibility.

External systems connect through Model Context Protocol (MCP) servers, a standard interface that lets an agent call outside tools. The Requirements Agent reaches Jira as the system of record for work; the Observability Agent talks to New Relic; the Testing Agent drives browsers through Playwright. Additional MCP servers connect Figma, Confluence, Context7 and internal design repositories. Because the connections are declared separately, a backend can be swapped without rewriting the agent itself. Everything runs on GitHub Copilot Cloud Agent, with shared skills so that enterprise best practices are written once and reused.

An agent is a Markdown file

Each agent is defined in a single Markdown file with a YAML frontmatter header and plain-text system instructions. The sample Requirements Agent definition specifies GPT-5.4 as its model and lists its MCP tools for Atlassian Jira and Confluence and for GitHub. Because the instructions are plain text, anyone on the team can read them and propose changes without machine learning expertise. Each definition states what the agent may do, which tools it may call and what it must not do.

The files live in an organization-level agents directory on GitHub, which makes them available in every repository in the company with no per-repo setup. Changes go through pull requests like any other code, so they are peer-reviewed, version-controlled and auditable.

From ticket to production, with two human gates

Requirements are written in EARS (Easy Approach to Requirements Syntax), a structured format for unambiguous specifications, and agents are instructed to stop and ask engineers for clarification when a ticket is unclear. Humans then act as mandatory checkpoints at exactly two points: reviewing and merging the specification pull request, and reviewing and merging the final production pull request.

Once the spec is merged, Copilot Cloud Agent produces an initial build and opens a draft pull request. Specialist agents run only as needed rather than all 17 on every change. Quality gates then execute in a fixed order:

  1. Unit and integration tests
  2. Accessibility
  3. Performance
  4. Code review
  5. Security

Security runs last on purpose, so it audits every modification the earlier agents made. The Observability Agent instruments the new code before any deployment recommendation, so telemetry is live the moment the change reaches production. The resulting pull request groups agent output into discrete, labeled commits with a consolidated summary. In one example, a migration of a developer portal to the Next.js App Router produced separate commits for the migration itself, Playwright test fixes, performance optimizations, accessibility adjustments and HTTP security headers, so a reviewer could inspect each fix on its own.

From ticket to production with two human gates Yes No New feature request arrives Requirements Agent draftsspec in EARS Ticket unclear? Ask engineersfor clarification Human reviews and mergesspec pull request Copilot Cloud Agent buildsand opens draft PR Specialist agents runonly as needed Quality gates in fixed ordertests first, security last Observability Agentinstruments new code Human reviews and mergesfinal production PR
▲ From ticket to production with two human gates

Standards carried by agents

Agent What it enforces How
Security OWASP vulnerabilities and CVEs Static audits, secret scans, remediation commits ordered by severity
Accessibility WCAG 2.2 AA Tests real page renders in headless browsers via Playwright and generates fixes in the PR
Performance Core Web Vitals Measures real metrics in live browser sessions rather than synthetic estimates
Observability Default New Relic tracing and alerts Injects missing instrumentation via pull request

Starter kits, autofix and an internal marketplace

Engineers browse a library-style marketplace of agent, skill and connector modules with star ratings

▲ Internal marketplace of agents, skills and MCP servers

New repositories start "agent-ready" through 10 standardized starter kits that span the company's main languages from TypeScript to Swift. Each kit ships with CI/CD workflows, documentation, runbooks, an AGENTS.md file and Copilot instructions. Continuous integration pipelines enforce dependency security review, automated tests, coverage thresholds and New Relic preflight validation on every pull request. When CI fails, Copilot Agentic Autofix reads the logs, generates a patch and pushes it back to the branch. For older repositories, audit agents compare the project against the starter kit templates and open upgrade pull requests to close gaps.

Discoverability comes from the LS&CO Developer AI Portal, an internal marketplace with 24 custom agents, 19 shared skills, 15 MCP servers and reusable prompt collections. Engineers can rate, comment on and review each item and install it into VS Code or GitHub with one click.

Tooling was easy; changing habits was not

The company says the tooling was the straightforward part. The heavy lift was change management, because shifts in role expectations create real anxiety. Its enablement playbook for a squad looks like this:

  • Pre-reads before the workshop, including industry research from Gartner and McKinsey, to encourage ambitious thinking.
  • An AI-expert principal engineer embedded in the squad as a player-coach, attending daily standups, answering chat questions and running coaching sessions.
  • Hands-on training on the squad's own production codebase rather than a sandbox.
  • Weekly developer velocity office hours as a judgment-free place for questions, demos of new capabilities and peer success stories.
  • A company-wide hackathon where every team had to use AI, preceded by pre-skilling workshops. Several hackathon projects have since moved into production, and an enterprise AI conference is planned for next year.

A Korn Ferry white paper the company cites suggests that high-performing engineers often experience the most friction, because AI asks them to abandon habits that made them successful. Engineers had to adopt spec-driven and test-first development and learn to review agent output critically. Daily standups shifted from status reporting to decisions and exceptions.

Four operating principles hold the system together: humans exercise judgment on ambiguous problems while agents handle execution; durable context lives in repositories and tickets, not in chat threads, which the company considers too transient for now; agents and humans clear the same CI/CD and review gates; and every agent action and human override is logged.

Results and lessons from one project

Metric Result
BackPocket delivery time 2.5 months, down from 9 months (72 percent faster)
Engineering throughput Up 51 percent
Pull request pass rate Up 54 percent
AI-assisted pull requests 26 percent to 69 percent, with a target of 100 percent

These are figures from one company's rollout, not a general benchmark. Leadership had expected throughput to dip during the transition, so the increase came as a surprise. The company also acknowledges that higher throughput can be an empty metric if agents simply generate more code, but argues that the rise in pass rates alongside fast MVP deliveries points to real value.

Two technical lessons stand out. Early attempts to let multiple agents work on parallel Git branches produced constant merge conflicts, so the team moved to sequential execution inside a single pull request: review agents post comments, and a helper agent resolves them one by one. And because agents tend to proceed with false confidence when a spec is incomplete, workflows must be designed to surface ambiguity early. On the organizational side, the original three-day workshop has been condensed into a three-hour format for onboarding additional squads.

What to take from this

The core lesson is that the agents were the last thing Levi Strauss & Co. built, not the first. The company defined success, mapped where time was actually lost, decided explicitly which work agents execute and which decisions humans keep, and only then wrote agent definitions and wired them to Jira, Confluence, New Relic and Playwright through MCP.

For teams considering a similar move, the design suggests a sequence:

  1. Write down what success means in business terms before touching tooling.
  2. Map the current process on paper and count the handoffs and waiting time.
  3. Sort every outcome into AI Does, Human Does and Human Decides, and keep the last two separate.
  4. Define each agent with a trigger, input, action, output and handoff, and store it as reviewable text in version control.
  5. Hold agents to the same gates as people, run security last, and keep humans on the spec and the final merge.
  6. Budget more effort for coaching and habit change than for installation.

The company sums up the warning with the image of a new motor in an old factory. Whether its numbers transfer to other organizations remains to be seen, but the blueprint for avoiding that mistake is unusually concrete.