# What the Top Companies Do Differently With AI Coding - Martin Harrysson & Prakhar Dixit, McKinsey

Martin Harrysson, McKinsey & Company · Prakhar Dixit, McKinsey & Company · Shilpa, McKinsey & Company

[Talk page](https://ai.engineer/talks/21tuT-e4NVo-what-top-companies-do-differently-ai-coding) · [Video](https://www.youtube.com/watch?v=21tuT-e4NVo)

## What the Top Companies Do Differently With AI Coding

When agents build and test overnight, the next morning’s work depends on who can judge the result, which requirements are ready and what it takes to release. McKinsey’s experience with large engineering organizations shows how those handoffs shape the gains from AI coding.

### A minority of enterprises reported gains across the whole cycle

[0:35](https://www.youtube.com/watch?v=21tuT-e4NVo&t=35s)

AI coding was already widespread among McKinsey’s large clients when a survey late in the previous year turned up a disappointing result. Most reported only modest performance improvements. Martin Harrysson, Prakhar Dixit and their colleague Shilpa worked with companies changing how their engineers developed software. Many had put new tools into an existing process in the hope that faster coding would speed up delivery.

A few months before the talk, McKinsey surveyed a few hundred large enterprises. A leading group, roughly 20–25% of respondents, reported improvements of about 2× across the product development life cycle. That was the result that caught Harrysson’s attention. A developer might finish coding 10–20% faster while the team still spends much of its time getting a change ready to build or ready to ship. The 2× claim concerned the process end to end. Harrysson left the common unit of measurement unspecified, so translating that figure into days saved per release would require more information.

Four patterns in the client work offered a way to understand that gap. Teams changed when people reviewed work, combined responsibilities in smaller groups and made company knowledge available to agents. The fourth change concerned everyone outside the pilot team. They, too, needed to know how to work this way.

![The operating model, talent and technology sit above change management and telemetry.](https://ai.engineer/api/talk-essay-media/069fdcb13b6d17ce8558bd29a8eb423e8f7ba71d93c3c910a3aec9e59501c595)

The presenters group the changes into operating model, talent and technology, with measurement and change management supporting all three.

### The overnight shift changes when people review work

[5:10](https://www.youtube.com/watch?v=21tuT-e4NVo&t=310s)

Some clients moved from two-week sprints to workflows lasting one or two days. In Dixit’s example, agents work the night shift. People validate the output the next day and send the work through again. Setting up the overnight run means deciding what an agent can carry forward on its own and where it must stop for a person to judge the result.

That stopping point can move. Once reviewers have confidence in a particular step, they can let the agent carry its output into the next stage before asking for review. Autonomy grows one handoff at a time. Six months to a year earlier, much of this work had concentrated on building and testing. Clients were beginning to use the same approach for product definition and release.

An overnight run also needs a dependable starting point. Teams in a large company may store the same kind of information in several places and describe it differently. Dixit suggested choosing the documents a workflow actually consumes, such as a product requirements document (PRD) or a specification, and giving each a consistent template. Then whichever team defines the work, the agent starts with a recognizable description of what to build.

### What a pod of two to four people can own

[7:14](https://www.youtube.com/watch?v=21tuT-e4NVo&t=434s)

Dixit saw clients form pods of two to four people. An organization could keep its engineers and form more teams that way. The change was especially visible at banks and other enterprises where work had previously passed through several layers of specialists. Responsibilities began to combine in two recognizable ways, even while job titles were still unsettled.

- **Definer.** Product roles converged around specifying what the team should build. A PRD gives that work an output the pod and its agents can use.
- **Builder.** Development and quality assurance increasingly belonged to the same role. The person responsible for producing a change also had to judge whether the result was good enough.

A pod can choose a capable coding tool and still need the colleague who has been at the company for 20 years. If that person alone knows how a system works, each agent run that needs the knowledge has to wait for their time. This is the practical purpose of what Dixit called a semantic layer. Once a company records its knowledge in a form agents can use, successive runs can draw on it. Trust poses a separate engineering question. How will the team govern what agents build and check that the result is secure and stable?

### A pilot can choose its own tools. A rollout needs curation.

[9:23](https://www.youtube.com/watch?v=21tuT-e4NVo&t=563s)

A pilot team building a product from scratch has favorable conditions. Its members can work out among themselves who defines the work, which tools to use and when to intervene. A striking delivery time on that project tells the next team little about how to repeat it. Before expanding across engineering, Dixit wanted companies to settle those operating decisions and account for the cost of running the agents across many teams.

Shilpa gave an example of a choice that could otherwise fall to every pod. A client wanted an agent skill for writing a simple PRD. A search turned up roughly 1,700 downloadable skills for that one task, and the client was stuck on which to choose. One way to narrow the field would be to ask which skills produce a PRD the team’s workflow can use. Dixit’s template gives that question a concrete reference. Curating a handful of skills that fit local practice would spare each team the same search and decision.

### Give agents examples that reviewers would accept

[11:35](https://www.youtube.com/watch?v=21tuT-e4NVo&t=695s)

Shilpa described reports of falling quality as code generation accelerated. The denominator matters here. A team opening more pull requests (PRs) can have more defects in total even if the likelihood of a defect in any one PR stays constant. Shilpa said the reports and data she had seen still showed worsening quality per developer and per pull request. For the people doing the work, the immediate concern was review skill. Developers and testers learning to generate code faster needed equal practice reading the result and deciding whether to accept it.

Reviewers can put that judgment to work before the agent writes code. A representative sample of a repository shows what engineers have typically written, including patterns they would prefer to retire. The team can instead curate **golden examples** that meet its standard and supply them alongside its policies. The examples show how an acceptable implementation looks in this codebase. The policies tell the agent which properties to preserve when the next task differs from the example.

A final quality gate can reject finished work. Giving the agent the relevant standard at each checkpoint lets that standard influence the work while there is still time to change it. This starts with the PRD. At the code checkpoint, the questions become specific. Can another engineer maintain the change? Has it introduced unnecessary complexity? Will it merge cleanly with work on the other branches?

![Four research figures on the slide concern duplication, security checks, complexity and bugs.](https://ai.engineer/api/talk-essay-media/44a8e875f40d39b14549e09249a366ee85ce2a7d84ccc3119656ad08e53db68a)

The slide tracks four code-quality signals across duplication, security checks, complexity and bugs.

### Faster builds expose delays upstream, downstream and sideways

[13:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=837s)

Where does a change spend its time once building and testing get faster? Shilpa highlighted those two stages in the middle of the development cycle. As they shrink, a team can run out of well-defined work at the front of the cycle or finish changes more frequently than it can release them at the other end. Either wait limits how quickly customers see an improvement.

- **Upstream, requirements need evidence.** Customer logs and emails give an agent information about the problems people experience. The next step is to connect that evidence to a requirement precise enough to guide what gets built.
- **Downstream, release has its own requirements.** A finished implementation reaches customers only as often as the enterprise can ship it. Mapping release requirements during planning gives the team a chance to satisfy them as it goes.

The less obvious delay comes from the side. A bank building a customer-facing application had rules about its color scheme. One practical question was whether a color-blind customer could tell which button to click. In the bank’s usual way of working, someone would find the team that knew the rules and sit down with them. Even with agents at every stage of development, the build could still depend on that conversation. Mapping the requirements held by design, risk, compliance and governance teams makes it possible to give an agent the relevant rule while it is doing the work.

![Arrows move from curation through verification, then return information from incidents to the next cycle.](https://ai.engineer/api/talk-essay-media/a56e5764f1cca49d6befc6a011c9c1fbdb6a552528d7087d473a09f51adc9aca)

The five-stage quality cycle shows where teams can catch mistakes as more code passes through agent-assisted development.

### What does a smaller team actually deliver?

[16:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=967s)

Organizations can count the tokens they consume, the tools they deploy and the people they retrain. Figuring out what that investment achieved remains harder. Harrysson saw a gap between widespread adoption and companies’ confidence in how they measured its impact. Clients continued to use familiar software delivery measures. A couple were also experimenting with AI to infer the intent of work and score its value. They hoped to use those scores to decide where to spend tokens and engineering time. Whether the scores predicted value for customers remained an open question.

Several clients used a simpler near-term calculation. Suppose an engineering leader estimates a job at three teams for eight weeks. Keep that estimate and cut each team to half its former size. If the three smaller pods deliver the same scope at comparable quality in eight weeks, the job still takes 24 team-weeks, but it uses half as many people. The other engineers can form three more pods to take on other work. The potential gain is extra capacity across the organization. The eight-week job itself still takes eight weeks, and counting the new pods tells the leader little until they deliver.

Harrysson closed with a broader observation from client work. He had seen gains of 2×, 3× or more on individual measures in a relatively short time. He attributed his optimism to seeing companies coordinate changes that depend on one another. A small pod can spend the morning reviewing an overnight build if a usable specification was ready the night before. Getting that build into a bank customer’s hands may still depend on whether the pod knew how the customer had to be able to distinguish the buttons.

## Key takeaways

- A consistent input and a known review point let people judge when an agent can carry a result through to the next stage on its own.
- More pull requests can raise the total incident count even at a steady defect rate. In the data Shilpa described, the adverse quality trend persisted per developer and per pull request, giving teams a reason to invest in review skills alongside code generation.
- Halving pod size can free people for parallel work if the smaller pods deliver comparable scope and quality in the same time. A team-week estimate hides that change in staffing.

## Slides

### Scaling agentic PDLC

McKinsey draws on its work with software teams to ask how people and their roles change as AI moves from helping developers write code to running the product lifecycle.

[0:12](https://www.youtube.com/watch?v=21tuT-e4NVo&t=12s) [Blue McKinsey & Company cover dated October 2026. The subtitle describes the shift from AI-assisted coding to an agent-run product lifecycle.](https://assets.ai.engineer/sites/aiecode2025/sha256/d2fb0a080a5a20100f58a91d3b2ba764e6559249abc2061056cb71016601bd6f.webp)

Scaling agentic PDLC
From AI-assisted coding to an agent-run product lifecycle
October 2026

McKinsey & Company

CONFIDENTIAL AND PROPRIETARY | © 2026 McKinsey & Company.
This material is intended solely for your internal use and any use of this material without specific permission of McKinsey & Company is strictly prohibited. All rights reserved.

Interface text: CC

### Agentic PDLC is climbing out of the trough

A blue dot above the rising slope asks which companies are emerging from disillusionment. In McKinsey’s recent survey of a few hundred large enterprises, the leading 20–25% were starting to see roughly 2× gains across the product lifecycle.

[1:21](https://www.youtube.com/watch?v=21tuT-e4NVo&t=81s) [A Gartner Hype Cycle plots expectations over time. A blue dot and an “Are you here?” callout sit above the rising slope between the trough and the productivity plateau.](https://assets.ai.engineer/sites/aiecode2025/sha256/20666e677ce8c88fb898dc90e6329e855d838bd51272fc97be4131887c6609f2.webp)

WHERE WE ARE
Agentic PDLC is climbing out of the trough

Y-axis: Expectations
X-axis: Time

Innovation Trigger
Peak of Inflated Expectations
Trough of Disillusionment
Slope of Enlightenment
Plateau of Productivity

Are you here?

Source: Gartner Hype Cycle
McKinsey & Company
2

Interface text: CC

### Where organizations get the agentic PDLC right

Teams redesign workflows around agents, form 2–4 person pods with new roles, and build systems that give agents the context they need. Change management and telemetry help all three shifts stick.

[3:31](https://www.youtube.com/watch?v=21tuT-e4NVo&t=211s) [Three cards labeled Operating model, Talent and Technology sit above a full-width bar identifying Change management & telemetry as their foundation.](https://assets.ai.engineer/sites/aiecode2025/sha256/486f82bb65ccad596e46d59b32fa4e7531c39a3c7f7f2d9f12adb887ecd55d7a.webp)

THE FOUR SHIFTS
Where organizations get the agentic PDLC right

A  Operating model
Redesign the flow — don't overlay agents on it

B  Talent
2–4 person pods with new roles, not smaller squads

C  Technology
The system around the agents, not the tool

D  Change management & telemetry
The foundation that decides whether A–C stick

Source: McKinsey client experience; DORA State of AI-assisted Software Development 2025; Gartner
McKinsey & Company
3

Interface text:
CC

### Talent

As pods of 2–4 replace squads of 8–10, one builder role combines development and QA. McKinsey projects that the same workforce, spread across more pods, could double capacity within 18–24 months.

[7:14](https://www.youtube.com/watch?v=21tuT-e4NVo&t=434s) [Shift B describes pods of two to four with Definer, Builder and Agent Ops roles. It projects doubled capacity at flat headcount within 18–24 months and emphasizes orchestration and specification writing.](https://assets.ai.engineer/sites/aiecode2025/sha256/cedb28fb5b454c80188eb97dc67be8bb86b6619789f29830a3ea2cde706cc3eb.webp)

THE FOUR SHIFTS
B
Talent
2–4 person pods with new roles, not smaller squads.

• Pods of 2–4 replace squads of 8–10 — over 50% leaner, at equal quality
• Roles collapse: PM/PO/BA → Definer, Dev/QA → Builder, DevOps → Agent Ops
• 2x capacity at flat headcount within 18–24 months
• Orchestration and spec-writing in; syntax out

McKinsey & Company
5

Interface text: CC

### Technology

Shared standards make choosing a coding tool a purchasing decision. A knowledge graph gives agents access to company know-how on demand. Six services help teams control what agents can access and check their work.

[8:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=491s) [Four blue bullets cover shared tool standards, a semantic layer for context, six services that support trust, and governance through skills, policy and metrics.](https://assets.ai.engineer/sites/aiecode2025/sha256/dc029c53520c633abf3edcbe3fb6bc4fedbd2df4651ecbf473d1f9cdfba64f12.webp)

THE FOUR SHIFTS
C
Technology
Tooling is not the bottleneck — the system around the agents is.

• Buy any tool — they all read the same standards now; procurement, not strategy
• The edge is the semantic layer: ontology, knowledge graph, context on demand
• Six services decide trust: IAM, observability, evals, MCP gateway, skills registry, FinOps
• Governed skills, enforced policy, trusted metrics

McKinsey & Company    6

Interface text:
CC

### Change & telemetry

To scale AI coding beyond pilots, support teams seeing the smallest gains. Set targets from day one, including at least $2 in value per $1 of agent compute. Give the token budget an owner and require verification before expanding.

[9:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=562s) [Three bullets call for adoption support where gains are smallest, outcome targets for time to market, quality and return on compute cost, and a named token-budget owner with verification before scaling.](https://assets.ai.engineer/sites/aiecode2025/sha256/f9812998ad1fc4af3be8f8dcc9ec7fe5f1978edbe3080494f3adae2a8e3f48cb.webp)

THE FOUR SHIFTS
D
Change & telemetry
The pillar that decides whether A–C stick.

• Usage is managed, not hoped for — enablement where gains are thinnest, not on power users
• Outcome KPIs from day one: 3x time to market, 2x quality, ROI floor of 2x value to agent-compute cost
• Guardrails before scale: a token budget with a named owner, verification as an enforced gate

McKinsey & Company     7

Interface text: CC

### Curation beats volume — govern the catalogue, don't grow it

Of ~1.9M public skills, an agent may load dozens, yet only 2–3 help. Teams can adapt a shared template, keep the mandatory golden path small, and require evaluations and evidence of use before promoting a sandbox skill.

[10:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=622s) [Three narrowing bars show about 1.9 million public skills, dozens loaded into an agent and 2–3 that help. Alongside them, three boxes describe configurable skills, centrally evaluated golden-path skills and sandbox skills that need evaluation and usage for promotion.](https://assets.ai.engineer/sites/aiecode2025/sha256/a0e3f7caad5f3603214e8169cce50d44c9ceffb685fbcd86ad94d8a24459ea35.webp)

SKILLS & GOVERNANCE
Curation beats volume — govern the catalogue, don't grow it

~1.9M public skills available
Dozens loaded into a single agent
2–3 actually help

Three tiers, three different bars

Configurable
One common skeleton, parameterized by repo, stack, regulatory perimeter

Golden path
Mandatory, centrally owned, evaluated. Deliberately few.

Sandbox
Anyone builds; nothing loads by default. Promotion needs evals + usage.

Source: McKinsey client experience; SkillsBench 2026; Snyk ToxicSkills; agentskills.io; MCP registry, Sept 2026
McKinsey & Company    8

Interface text:
CC

### As agents write most of the code, quality is slipping

Across 22,000 developers, Faros found 54% more bugs per developer and roughly three times as many incidents per pull request. The speakers recommend giving agents policies and examples and enforcing quality checks in code.

[11:33](https://www.youtube.com/watch?v=21tuT-e4NVo&t=693s) [Four cards report an 81% increase in duplicated code blocks, a security pass rate near 55%, a 42% increase in code complexity and a 54% increase in bugs per developer. The closing line recommends policy, examples and executable quality checks.](https://assets.ai.engineer/sites/aiecode2025/sha256/b7edfa2a6d3b91b7ad78defdc7df3d645b3abe0ac3cf5980ce856bb088fa9ddb.webp)

QUALITY & RISK
As agents write most of the code, quality is slipping

+81% duplicated code blocks; refactoring fell 21% → 3.8%
GitClear, 623M changes

~55% security pass rate — flat for two years
Veracode, 150+ models

+42% code complexity, persisting after the line spike
CMU, 806 repos

+54% bugs per developer; incidents per PR ~3x
Faros, 22,000 developers

The fix: build quality in — policy & exemplars as context, executable gates as code.

Source: GitClear 2026; Veracode Spring 2026 GenAI Code Security Report; CMU; Faros AI 2026
McKinsey & Company    9

Interface text:
CC

### Five stages that make each cycle better than the last

Teams give coding agents reference implementations and mandatory checks. They start with the spec and tests, use a stronger model for review, and turn every escaped defect or incident into an example, rule or evaluation for the next cycle.

[12:37](https://www.youtube.com/watch?v=21tuT-e4NVo&t=757s) [Five arrows read Curate, Feed forward, Generate, Verify and Capture. The final stage turns escaped defects and incidents into examples, rules or evaluations for the next cycle.](https://assets.ai.engineer/sites/aiecode2025/sha256/68b2129bf5cdceadf15c284f318cf2d96f5aafc79dc41d6530d70a3e747745f1.webp)

QUALITY & RISK
Five stages that make each cycle better than the last

Curate
Golden examples & reference implementations — not the codebase average

Feed forward
Thin rules, 2–3 focused skills, exemplars + checks the agent can't skip

Generate
Spec and tests first; reviewer model stronger than the implementer

Verify
Mutation score, not coverage; agentic review on 50–80% of PRs; SAST backstop

Capture
Every escaped defect & incident becomes a new exemplar, rule or eval

A closed loop: capture feeds back into curate — policy and quality are the same pattern.

Source: McKinsey client experience; Anthropic Claude Code best practices
McKinsey & Company    10

Interface text:
CC

### Adoption is near-universal, impact goes unmeasured

84–90% of developers have adopted AI coding tools. To judge what teams gain, track how long ideas take to reach production and what share of releases hit their targets within 90 days. Use quality and risk as guardrails.

[16:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=964s) [Three cards report that 84–90% of developers have adopted AI coding tools, 20% use engineering metrics to measure AI impact, and 40%+ of agentic AI projects may be cancelled by 2027. Below, the slide highlights time to value, value realized, and quality and risk.](https://assets.ai.engineer/sites/aiecode2025/sha256/092f8c53044a091509d70eb0e1bd964e956c076a41398b125f4e14ae83e90cdb.webp)

MEASUREMENT
Adoption is near-universal, impact goes unmeasured

84–90% of developers have adopted AI coding tools
20% use engineering metrics to measure AI impact
40%+ of agentic AI projects may be cancelled by 2027

Measure outcomes, not activity

Time to value
Idea-to-production lead time

Value realized
% of releases hitting their success metric in 90 days

Quality & risk
The guardrail that keeps the rest honest

Source: Stack Overflow 2025; JetBrains 2025; MIT NANDA 2025; Gartner 2025/2026; Faros AI 2026; McKinsey
McKinsey & Company    12

Interface text:
CC

### What good looks like

Once teams have chosen their AI coding tools, the work shifts to how they develop software with agents. They can build quality checks into that workflow and judge the changes by what the team delivers.

[19:01](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1141s) [Large white text on a blue background calls for redesigning the workflow, building in quality and measuring outcomes. A closing line says the work is in the system around the agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/3d1d291c673c93a50dd92b1bf443555be1486a16fa64226e77511e8d63ce3c15.webp)

What good looks like

Redesign the flow. Build quality in.
Measure outcomes, not activity.

The tooling is settled. The system around the agents is the work.

Interface text: CC

## Full transcript

[0:01](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1s) [music]

[0:12](https://www.youtube.com/watch?v=21tuT-e4NVo&t=12s) All right, good morning everyone. Um,

[0:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=15s) thanks for hanging with us here. I think

[0:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=16s) we're coming up to lunch, so we'll uh um

[0:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=20s) we we're going to do uh one more session

[0:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=22s) here. Um so I think you've heard from a

[0:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=25s) number of different speakers around what

[0:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=27s) they're doing in their uh

[0:28](https://www.youtube.com/watch?v=21tuT-e4NVo&t=28s) transformations around using AI and

[0:31](https://www.youtube.com/watch?v=21tuT-e4NVo&t=31s) Aentic and in the software development.

[0:33](https://www.youtube.com/watch?v=21tuT-e4NVo&t=33s) Uh we're going to talk a little bit more

[0:35](https://www.youtube.com/watch?v=21tuT-e4NVo&t=35s) about what are we seeing across. So we

[0:37](https://www.youtube.com/watch?v=21tuT-e4NVo&t=37s) have the we have the benefit of um

[0:40](https://www.youtube.com/watch?v=21tuT-e4NVo&t=40s) seeing a lot of these transformation at

[0:42](https://www.youtube.com/watch?v=21tuT-e4NVo&t=42s) a lot of our clients. So you know we're

[0:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=45s) we're from Mckenzie. Uh I'm Martin

[0:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=47s) Harrison. This is uh Preer and Shelpa my

[0:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=50s) colleagues. And so uh we're all from our

[0:53](https://www.youtube.com/watch?v=21tuT-e4NVo&t=53s) practice that work with clients on

[0:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=56s) transforming uh software engineering and

[0:58](https://www.youtube.com/watch?v=21tuT-e4NVo&t=58s) and how that's changing with with AI and

[1:01](https://www.youtube.com/watch?v=21tuT-e4NVo&t=61s) Agentic and and so we spend a lot of

[1:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=64s) time in particular on the people and

[1:06](https://www.youtube.com/watch?v=21tuT-e4NVo&t=66s) operating model uh side of things. And

[1:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=69s) so we're going to talk a little bit

[1:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=71s) about what are some of the things that

[1:12](https://www.youtube.com/watch?v=21tuT-e4NVo&t=72s) we're seeing across clients and and what

[1:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=75s) are the some of the things that we see

[1:17](https://www.youtube.com/watch?v=21tuT-e4NVo&t=77s) make the biggest difference when it

[1:19](https://www.youtube.com/watch?v=21tuT-e4NVo&t=79s) comes to uh having impact.

[1:23](https://www.youtube.com/watch?v=21tuT-e4NVo&t=83s) So I think um uh as we sort of take a

[1:28](https://www.youtube.com/watch?v=21tuT-e4NVo&t=88s) quick step back and see a little bit

[1:30](https://www.youtube.com/watch?v=21tuT-e4NVo&t=90s) like where where are we when it comes to

[1:32](https://www.youtube.com/watch?v=21tuT-e4NVo&t=92s) AI in uh in software development um I

[1:37](https://www.youtube.com/watch?v=21tuT-e4NVo&t=97s) think it's it's probably it's probably

[1:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=99s) hard to put what like one point on this

[1:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=101s) exactly but I'm optimistic and I think

[1:43](https://www.youtube.com/watch?v=21tuT-e4NVo&t=103s) that we're coming out of this trough of

[1:46](https://www.youtube.com/watch?v=21tuT-e4NVo&t=106s) disillusionment. Uh I think this is you

[1:48](https://www.youtube.com/watch?v=21tuT-e4NVo&t=108s) know this has been a space that has

[1:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=110s) arguably had perhaps seen the most

[1:52](https://www.youtube.com/watch?v=21tuT-e4NVo&t=112s) impact of AI over the last 2 three years

[1:55](https://www.youtube.com/watch?v=21tuT-e4NVo&t=115s) and it was quick out of the gates so to

[1:58](https://www.youtube.com/watch?v=21tuT-e4NVo&t=118s) speak and everyone's been talking about

[2:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=120s) agentic coding uh for a while now and I

[2:03](https://www.youtube.com/watch?v=21tuT-e4NVo&t=123s) think the expectations became became

[2:06](https://www.youtube.com/watch?v=21tuT-e4NVo&t=126s) huge when we when we surveyed a lot of

[2:08](https://www.youtube.com/watch?v=21tuT-e4NVo&t=128s) our clients sort of end of last year it

[2:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=131s) was though it was a huge um mismatch

[2:14](https://www.youtube.com/watch?v=21tuT-e4NVo&t=134s) between uh the where we actually were in

[2:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=138s) the expectations and so most most of our

[2:21](https://www.youtube.com/watch?v=21tuT-e4NVo&t=141s) large companies are quoted relatively

[2:23](https://www.youtube.com/watch?v=21tuT-e4NVo&t=143s) meager performance improvements even

[2:26](https://www.youtube.com/watch?v=21tuT-e4NVo&t=146s) though everyone was using AI and

[2:28](https://www.youtube.com/watch?v=21tuT-e4NVo&t=148s) software development. Uh the reason the

[2:32](https://www.youtube.com/watch?v=21tuT-e4NVo&t=152s) reason we think that we're now maybe

[2:34](https://www.youtube.com/watch?v=21tuT-e4NVo&t=154s) heading out of this uh is that when we

[2:37](https://www.youtube.com/watch?v=21tuT-e4NVo&t=157s) re we relooked at this uh just a few

[2:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=159s) months ago. So, we surveyed a few

[2:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=161s) hundred of our of our clients and and uh

[2:44](https://www.youtube.com/watch?v=21tuT-e4NVo&t=164s) large large enterprises and this it's

[2:48](https://www.youtube.com/watch?v=21tuT-e4NVo&t=168s) clear that there's a there's a top sort

[2:51](https://www.youtube.com/watch?v=21tuT-e4NVo&t=171s) of there's a 20 25% of uh of companies

[2:54](https://www.youtube.com/watch?v=21tuT-e4NVo&t=174s) that are really starting to see uh some

[2:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=177s) some pretty massive benefits. And when

[3:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=180s) we talk when we mean what we mean with

[3:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=182s) that is not just the sort of 10 15 20%

[3:05](https://www.youtube.com/watch?v=21tuT-e4NVo&t=185s) like a little bit faster uh coding and

[3:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=189s) and sort of going through the the PDLC

[3:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=191s) but real you know 2x like end to end

[3:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=195s) improvements

[3:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=196s) and so uh I don't think everyone's

[3:19](https://www.youtube.com/watch?v=21tuT-e4NVo&t=199s) necessarily uh everyone's dot is like on

[3:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=202s) you know all the way out of this uh yet

[3:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=205s) but I I'm very optimistic that we're

[3:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=207s) heading in in the right direction.

[3:31](https://www.youtube.com/watch?v=21tuT-e4NVo&t=211s) And so what we're we're going to cover

[3:33](https://www.youtube.com/watch?v=21tuT-e4NVo&t=213s) now in the next uh 15 or so minutes are

[3:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=216s) a few of the things that we see as

[3:37](https://www.youtube.com/watch?v=21tuT-e4NVo&t=217s) patterns that that seems to be working

[3:40](https://www.youtube.com/watch?v=21tuT-e4NVo&t=220s) really well. And so we're going to talk

[3:42](https://www.youtube.com/watch?v=21tuT-e4NVo&t=222s) a little bit about uh these four

[3:44](https://www.youtube.com/watch?v=21tuT-e4NVo&t=224s) elements on the operating model. What

[3:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=227s) are some of the things that we we see

[3:49](https://www.youtube.com/watch?v=21tuT-e4NVo&t=229s) changing there? Um we see a a true

[3:52](https://www.youtube.com/watch?v=21tuT-e4NVo&t=232s) redesign of the flow. I think we've

[3:54](https://www.youtube.com/watch?v=21tuT-e4NVo&t=234s) we've so far seen a lot of our clients

[3:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=237s) trying to use more tools in the same

[4:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=240s) process and and trying to get things

[4:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=242s) sped up and it's it's just not working.

[4:05](https://www.youtube.com/watch?v=21tuT-e4NVo&t=245s) On the on the talent and people side

[4:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=247s) here, we're seeing a massive difference.

[4:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=249s) I think we're we're seeing a lot of uh

[4:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=251s) or several of our clients moving away

[4:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=253s) from the typical scrum teams into much

[4:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=256s) smaller pods. And we can talk a little

[4:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=258s) bit more about what that looks like and

[4:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=260s) and I know that's probably come up in

[4:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=262s) some of these other talks as well. So

[4:24](https://www.youtube.com/watch?v=21tuT-e4NVo&t=264s) we'll we'll talk about what we're seeing

[4:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=265s) across here and and then on the on the

[4:29](https://www.youtube.com/watch?v=21tuT-e4NVo&t=269s) tech side. I mean I think we're all this

[4:31](https://www.youtube.com/watch?v=21tuT-e4NVo&t=271s) is a a a crowd that is obviously uh have

[4:35](https://www.youtube.com/watch?v=21tuT-e4NVo&t=275s) seen all the tools and so on and and

[4:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=276s) they're very they're really amazing. I

[4:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=279s) think it's much more about how do you

[4:40](https://www.youtube.com/watch?v=21tuT-e4NVo&t=280s) construct a stack that really works for

[4:42](https://www.youtube.com/watch?v=21tuT-e4NVo&t=282s) you and how do you get the right

[4:44](https://www.youtube.com/watch?v=21tuT-e4NVo&t=284s) context. Uh I think we heard that in the

[4:46](https://www.youtube.com/watch?v=21tuT-e4NVo&t=286s) from the previous speaker as well. How

[4:49](https://www.youtube.com/watch?v=21tuT-e4NVo&t=289s) do you set up like a a data and context

[4:51](https://www.youtube.com/watch?v=21tuT-e4NVo&t=291s) foundation that actually serves you

[4:53](https://www.youtube.com/watch?v=21tuT-e4NVo&t=293s) right? And then on on the last part so

[4:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=296s) much about this is around change

[4:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=297s) management. Um we're al fundamentally

[5:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=300s) like changing how people do work and

[5:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=302s) that's that's never easy and it's not

[5:05](https://www.youtube.com/watch?v=21tuT-e4NVo&t=305s) really going at a gentic speed yet for

[5:08](https://www.youtube.com/watch?v=21tuT-e4NVo&t=308s) the most part.

[5:10](https://www.youtube.com/watch?v=21tuT-e4NVo&t=310s) Thanks Martin. I'll I'll cover a little

[5:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=313s) bit of each of the four aspects that

[5:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=315s) Martin talked about and what we are

[5:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=316s) seeing as changes across those. So on

[5:19](https://www.youtube.com/watch?v=21tuT-e4NVo&t=319s) the operating model side, I think you

[5:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=320s) probably have seen some of this

[5:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=322s) happening in your own organizations as

[5:23](https://www.youtube.com/watch?v=21tuT-e4NVo&t=323s) well. Many because of the changes that

[5:26](https://www.youtube.com/watch?v=21tuT-e4NVo&t=326s) the agents are bringing to the PDLC, the

[5:29](https://www.youtube.com/watch?v=21tuT-e4NVo&t=329s) cycles themselves have shifted, right?

[5:31](https://www.youtube.com/watch?v=21tuT-e4NVo&t=331s) This traditional twoe sprint, the scrum

[5:33](https://www.youtube.com/watch?v=21tuT-e4NVo&t=333s) team model doesn't work anymore in this

[5:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=336s) newly agentic PDLC. And we are seeing a

[5:38](https://www.youtube.com/watch?v=21tuT-e4NVo&t=338s) lot of our clients shift more towards

[5:40](https://www.youtube.com/watch?v=21tuT-e4NVo&t=340s) more a conman style but one day two day

[5:42](https://www.youtube.com/watch?v=21tuT-e4NVo&t=342s) workflows that are running where agents

[5:44](https://www.youtube.com/watch?v=21tuT-e4NVo&t=344s) are running the night shift humans are

[5:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=345s) validating the output and then rerunning

[5:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=347s) the loop etc. Now that requires setup of

[5:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=350s) the agent flows in a way that you can do

[5:52](https://www.youtube.com/watch?v=21tuT-e4NVo&t=352s) it. So that's the work that's needed to

[5:54](https://www.youtube.com/watch?v=21tuT-e4NVo&t=354s) be done but once you do it you can't go

[5:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=356s) back to the older model of doing the

[5:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=357s) twoe sprints. Um and that requires where

[6:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=360s) you basically set the guardrails for

[6:03](https://www.youtube.com/watch?v=21tuT-e4NVo&t=363s) human reviews, right? So a lot of our

[6:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=364s) clients are deciding where they want the

[6:06](https://www.youtube.com/watch?v=21tuT-e4NVo&t=366s) human review in the loop and when they

[6:08](https://www.youtube.com/watch?v=21tuT-e4NVo&t=368s) are confident on that loop, they take

[6:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=369s) the human review back and let the loop

[6:12](https://www.youtube.com/watch?v=21tuT-e4NVo&t=372s) go to the next one and so on and so

[6:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=373s) forth. So depending on the confidence

[6:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=375s) and the majority of the clients, we are

[6:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=376s) seeing that happen more and more where

[6:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=378s) these loops are more autonomous end to

[6:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=380s) end orchestrated. Um and I think last

[6:24](https://www.youtube.com/watch?v=21tuT-e4NVo&t=384s) year or even 6 months ago, a lot of

[6:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=385s) those loops were more around the build

[6:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=387s) and the test part of the cycle. Now we

[6:28](https://www.youtube.com/watch?v=21tuT-e4NVo&t=388s) have seen that actually expand more

[6:30](https://www.youtube.com/watch?v=21tuT-e4NVo&t=390s) towards the product side and the release

[6:32](https://www.youtube.com/watch?v=21tuT-e4NVo&t=392s) side as well and Shalpa will talk a

[6:33](https://www.youtube.com/watch?v=21tuT-e4NVo&t=393s) little bit about what that means in

[6:34](https://www.youtube.com/watch?v=21tuT-e4NVo&t=394s) terms of where the bottlenecks are today

[6:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=396s) compared to where they were before. Um

[6:38](https://www.youtube.com/watch?v=21tuT-e4NVo&t=398s) and then the last thing I would say on

[6:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=399s) the operating model is it is very

[6:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=401s) critical that uh the artifacts or the

[6:44](https://www.youtube.com/watch?v=21tuT-e4NVo&t=404s) codification of what we are using to

[6:46](https://www.youtube.com/watch?v=21tuT-e4NVo&t=406s) feed into these loops is predefined

[6:48](https://www.youtube.com/watch?v=21tuT-e4NVo&t=408s) right and they are kind of standardized.

[6:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=410s) You have a template because a lot of our

[6:52](https://www.youtube.com/watch?v=21tuT-e4NVo&t=412s) clients and anybody who has more than 5

[6:54](https://www.youtube.com/watch?v=21tuT-e4NVo&t=414s) 600 people in their organization have

[6:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=416s) multiple different ways of storing the

[6:58](https://www.youtube.com/watch?v=21tuT-e4NVo&t=418s) data and storing the context and for

[7:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=420s) some specific artifacts within the loop

[7:03](https://www.youtube.com/watch?v=21tuT-e4NVo&t=423s) and everyone decides what those are the

[7:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=424s) PRD specs wherever they are having that

[7:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=427s) um consistent standardized artifacts

[7:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=429s) helps a lot in making sure that you are

[7:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=431s) actually moving towards this operating

[7:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=433s) model.

[7:14](https://www.youtube.com/watch?v=21tuT-e4NVo&t=434s) Um on the talent side, Martin touched a

[7:17](https://www.youtube.com/watch?v=21tuT-e4NVo&t=437s) little bit of this as well, but we are

[7:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=438s) increasingly seeing the structure and

[7:21](https://www.youtube.com/watch?v=21tuT-e4NVo&t=441s) the size of the teams shrink. Um that

[7:24](https://www.youtube.com/watch?v=21tuT-e4NVo&t=444s) doesn't necessarily mean that people are

[7:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=445s) reducing headcount. It means that you

[7:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=447s) have more teams, but smaller teams, pods

[7:29](https://www.youtube.com/watch?v=21tuT-e4NVo&t=449s) of two to four is what we are seeing.

[7:32](https://www.youtube.com/watch?v=21tuT-e4NVo&t=452s) That also has an implication on what the

[7:34](https://www.youtube.com/watch?v=21tuT-e4NVo&t=454s) responsibilities of those roles are. We

[7:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=456s) are seeing them um collapse in terms of

[7:38](https://www.youtube.com/watch?v=21tuT-e4NVo&t=458s) what their responsibilities are. And

[7:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=459s) this is true especially for larger

[7:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=461s) enterprises, banks, etc. where there

[7:43](https://www.youtube.com/watch?v=21tuT-e4NVo&t=463s) were multiple different layers of roles.

[7:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=465s) They're all moving towards like one

[7:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=467s) standardized definition. I don't think

[7:49](https://www.youtube.com/watch?v=21tuT-e4NVo&t=469s) the industry has agreed on what they

[7:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=470s) will be called but you know the product

[7:52](https://www.youtube.com/watch?v=21tuT-e4NVo&t=472s) type of roles are moving towards more

[7:53](https://www.youtube.com/watch?v=21tuT-e4NVo&t=473s) what we call a definer role. The dev QA

[7:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=476s) roles are moving more towards type of a

[7:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=477s) builder role etc. But we are

[7:59](https://www.youtube.com/watch?v=21tuT-e4NVo&t=479s) increasingly seeing that happen

[8:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=480s) organically across most of my clients

[8:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=482s) because they are realizing that a lot of

[8:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=484s) the manual activities that these roles

[8:05](https://www.youtube.com/watch?v=21tuT-e4NVo&t=485s) were doing can be identified and the

[8:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=487s) responsibilities are expanding across um

[8:10](https://www.youtube.com/watch?v=21tuT-e4NVo&t=490s) all of those

[8:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=493s) on the tech side. Um I think the maybe

[8:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=496s) this audience is not the right audience

[8:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=498s) to say this, but the tooling part of it

[8:19](https://www.youtube.com/watch?v=21tuT-e4NVo&t=499s) right is quote unquote solved. I would

[8:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=502s) say most of the tools that are out there

[8:24](https://www.youtube.com/watch?v=21tuT-e4NVo&t=504s) in the market right now are doing great,

[8:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=505s) right? So it's not a question of whether

[8:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=507s) the tool will work or not. It's more

[8:29](https://www.youtube.com/watch?v=21tuT-e4NVo&t=509s) what Martin was saying is like how do

[8:30](https://www.youtube.com/watch?v=21tuT-e4NVo&t=510s) you organize your stack around those

[8:32](https://www.youtube.com/watch?v=21tuT-e4NVo&t=512s) tools that work in your context

[8:34](https://www.youtube.com/watch?v=21tuT-e4NVo&t=514s) specifically. Um and I think the edge

[8:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=516s) that organizations right now have that

[8:38](https://www.youtube.com/watch?v=21tuT-e4NVo&t=518s) is that the semantic layer how they are

[8:40](https://www.youtube.com/watch?v=21tuT-e4NVo&t=520s) building it. What's their IP? What's

[8:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=521s) their context? What's their knowledge?

[8:42](https://www.youtube.com/watch?v=21tuT-e4NVo&t=522s) Again, for larger clients, the challenge

[8:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=525s) is that a lot of that context sits in

[8:46](https://www.youtube.com/watch?v=21tuT-e4NVo&t=526s) the head of likememes, people who have

[8:48](https://www.youtube.com/watch?v=21tuT-e4NVo&t=528s) been there for 20 years. How do you make

[8:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=530s) sure that agents get that context again

[8:52](https://www.youtube.com/watch?v=21tuT-e4NVo&t=532s) and again and do not have to depend on

[8:54](https://www.youtube.com/watch?v=21tuT-e4NVo&t=534s) those bottlenecks, which is not a new

[8:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=536s) problem. This was a problem 20 years ago

[8:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=537s) as well. Now that agents are actually

[8:59](https://www.youtube.com/watch?v=21tuT-e4NVo&t=539s) needing that context, you have to

[9:01](https://www.youtube.com/watch?v=21tuT-e4NVo&t=541s) document that knowledge in some way that

[9:03](https://www.youtube.com/watch?v=21tuT-e4NVo&t=543s) can be used by the agents. Um and can't

[9:05](https://www.youtube.com/watch?v=21tuT-e4NVo&t=545s) emphasize enough you will see a lots of

[9:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=547s) talk around this at AIE itself is the

[9:10](https://www.youtube.com/watch?v=21tuT-e4NVo&t=550s) trust

[9:10](https://www.youtube.com/watch?v=21tuT-e4NVo&t=550s) [snorts]

[9:10](https://www.youtube.com/watch?v=21tuT-e4NVo&t=550s) layer right like how do you make sure

[9:12](https://www.youtube.com/watch?v=21tuT-e4NVo&t=552s) that these agents are building the

[9:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=553s) things in the right way what are the

[9:14](https://www.youtube.com/watch?v=21tuT-e4NVo&t=554s) things that are needed for governance

[9:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=556s) for you know making sure that they are

[9:17](https://www.youtube.com/watch?v=21tuT-e4NVo&t=557s) secure and they are stable um that is

[9:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=560s) becoming increasingly more and more

[9:21](https://www.youtube.com/watch?v=21tuT-e4NVo&t=561s) important

[9:23](https://www.youtube.com/watch?v=21tuT-e4NVo&t=563s) and then the last part on this is change

[9:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=565s) um I think the

[9:28](https://www.youtube.com/watch?v=21tuT-e4NVo&t=568s) doing this and we have all seen this

[9:29](https://www.youtube.com/watch?v=21tuT-e4NVo&t=569s) doing this in pockets and pilots and

[9:31](https://www.youtube.com/watch?v=21tuT-e4NVo&t=571s) front runner teams has always been

[9:32](https://www.youtube.com/watch?v=21tuT-e4NVo&t=572s) easier especially for if you're building

[9:34](https://www.youtube.com/watch?v=21tuT-e4NVo&t=574s) something from scratch net new that has

[9:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=576s) for the last year or so everyone has

[9:38](https://www.youtube.com/watch?v=21tuT-e4NVo&t=578s) done that and that's the reports that

[9:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=579s) get published right like oh this team

[9:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=581s) did this and like got 10x productivity

[9:43](https://www.youtube.com/watch?v=21tuT-e4NVo&t=583s) in like 6 days whereas it would have

[9:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=585s) taken 9 months to do blah blah blah but

[9:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=587s) the real change requires you to like

[9:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=590s) scale this across hundreds of thousands

[9:52](https://www.youtube.com/watch?v=21tuT-e4NVo&t=592s) of engineers um and I think for that you

[9:54](https://www.youtube.com/watch?v=21tuT-e4NVo&t=594s) need to prep a little bit before you

[9:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=596s) actually unleash your agent PDLC on the

[9:58](https://www.youtube.com/watch?v=21tuT-e4NVo&t=598s) rest of the organization you need to

[10:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=600s) create a structure where you have um

[10:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=602s) thought about not just what those agents

[10:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=604s) are but all the things that we talked

[10:05](https://www.youtube.com/watch?v=21tuT-e4NVo&t=605s) about what your operating model is what

[10:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=607s) the talent structure is going to look

[10:08](https://www.youtube.com/watch?v=21tuT-e4NVo&t=608s) like how are you going to organize

[10:10](https://www.youtube.com/watch?v=21tuT-e4NVo&t=610s) around the stack and more importantly

[10:12](https://www.youtube.com/watch?v=21tuT-e4NVo&t=612s) these days how are you going to think

[10:14](https://www.youtube.com/watch?v=21tuT-e4NVo&t=614s) about your cost for those agents that

[10:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=615s) you are deploying right so AIO ops has

[10:17](https://www.youtube.com/watch?v=21tuT-e4NVo&t=617s) obviously become very important um with

[10:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=620s) that maybe Shelpa you want to take the

[10:24](https://www.youtube.com/watch?v=21tuT-e4NVo&t=624s) sure um I think the last point I would

[10:26](https://www.youtube.com/watch?v=21tuT-e4NVo&t=626s) say and this is connected to the tech

[10:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=627s) point is on the skills part the

[10:30](https://www.youtube.com/watch?v=21tuT-e4NVo&t=630s) challenge I think is not right now there

[10:32](https://www.youtube.com/watch?v=21tuT-e4NVo&t=632s) is enough skills available in the market

[10:34](https://www.youtube.com/watch?v=21tuT-e4NVo&t=634s) and everyone is creating more and more.

[10:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=636s) I think curation is what has become more

[10:38](https://www.youtube.com/watch?v=21tuT-e4NVo&t=638s) critical. Most of my clients they ask me

[10:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=641s) this question on like hey do you see

[10:42](https://www.youtube.com/watch?v=21tuT-e4NVo&t=642s) these like skills there are so many

[10:44](https://www.youtube.com/watch?v=21tuT-e4NVo&t=644s) frameworks how can we use them etc. I

[10:46](https://www.youtube.com/watch?v=21tuT-e4NVo&t=646s) don't think the answer is that the

[10:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=647s) skills won't be available or can't be uh

[10:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=650s) made available to your organization.

[10:52](https://www.youtube.com/watch?v=21tuT-e4NVo&t=652s) Right? The challenge is more whether you

[10:53](https://www.youtube.com/watch?v=21tuT-e4NVo&t=653s) can curate the right ones that fit in

[10:55](https://www.youtube.com/watch?v=21tuT-e4NVo&t=655s) the right context for you. Um you will

[10:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=657s) have hundreds of thousands of skills

[10:58](https://www.youtube.com/watch?v=21tuT-e4NVo&t=658s) that are easily accessible. There will

[11:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=660s) only be a few handful of those that are

[11:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=662s) actually meaningful for your

[11:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=664s) organization for your teams. So curating

[11:06](https://www.youtube.com/watch?v=21tuT-e4NVo&t=666s) that is where I think a lot of my

[11:08](https://www.youtube.com/watch?v=21tuT-e4NVo&t=668s) clients need to spend their time and

[11:10](https://www.youtube.com/watch?v=21tuT-e4NVo&t=670s) it's changing so fast because it's like

[11:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=671s) there is a proliferation for the same. I

[11:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=673s) was talking to a client yesterday for

[11:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=675s) just writing a simple product

[11:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=676s) requirement document. They just

[11:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=678s) literally Googled and there are like

[11:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=680s) 1,700 skills that you can download just

[11:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=682s) for that one task. Right? Now, which one

[11:24](https://www.youtube.com/watch?v=21tuT-e4NVo&t=684s) do you use? And it's like paralysis in

[11:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=687s) decision-m that's where they are

[11:28](https://www.youtube.com/watch?v=21tuT-e4NVo&t=688s) struggling the most. So that curation

[11:30](https://www.youtube.com/watch?v=21tuT-e4NVo&t=690s) becomes a lot more important now.

[11:35](https://www.youtube.com/watch?v=21tuT-e4NVo&t=695s) Perfect. I'm going to touch upon one

[11:37](https://www.youtube.com/watch?v=21tuT-e4NVo&t=697s) aspect of this acceleration which is

[11:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=699s) actually creating inverse impact on

[11:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=701s) quality which is the fact that as we get

[11:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=705s) code generation faster and faster. A lot

[11:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=707s) of the reports and data that we're

[11:49](https://www.youtube.com/watch?v=21tuT-e4NVo&t=709s) seeing is actually pointing towards

[11:51](https://www.youtube.com/watch?v=21tuT-e4NVo&t=711s) quality not going in the same direction

[11:53](https://www.youtube.com/watch?v=21tuT-e4NVo&t=713s) and in fact inversely going down. And

[11:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=716s) some of it you would expect because if

[11:58](https://www.youtube.com/watch?v=21tuT-e4NVo&t=718s) the frequency of your code commits your

[12:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=720s) PRs is increasing you would you're bound

[12:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=722s) to see more incidents more uh quality

[12:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=724s) defects and so on. But actually in the

[12:06](https://www.youtube.com/watch?v=21tuT-e4NVo&t=726s) data even on a per developer basis even

[12:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=729s) on a per PR basis uh we are seeing the

[12:12](https://www.youtube.com/watch?v=21tuT-e4NVo&t=732s) trend downwards in terms of the of the

[12:14](https://www.youtube.com/watch?v=21tuT-e4NVo&t=734s) bugs and the incidents that are getting

[12:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=735s) reported and the fundamental of it comes

[12:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=738s) down to the fact that you would want to

[12:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=740s) coach your developers testers on of

[12:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=742s) course using AI and tools and and

[12:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=745s) getting faster acceleration to generate

[12:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=747s) code but then the the skill set of

[12:30](https://www.youtube.com/watch?v=21tuT-e4NVo&t=750s) reviewing and really looking at what has

[12:33](https://www.youtube.com/watch?v=21tuT-e4NVo&t=753s) been generated is that good or not uh

[12:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=756s) also needs an equal emphasis and from

[12:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=759s) that perspective uh a lot of the work

[12:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=761s) that we're doing we are focusing on

[12:43](https://www.youtube.com/watch?v=21tuT-e4NVo&t=763s) first of all curating what are good

[12:46](https://www.youtube.com/watch?v=21tuT-e4NVo&t=766s) examples that we can actually feed uh to

[12:49](https://www.youtube.com/watch?v=21tuT-e4NVo&t=769s) the agents that are that are supporting

[12:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=770s) the PDLC cross and cross and and those

[12:53](https://www.youtube.com/watch?v=21tuT-e4NVo&t=773s) examples one of the policies is you

[12:55](https://www.youtube.com/watch?v=21tuT-e4NVo&t=775s) don't want that to be the average of

[12:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=777s) your codebase you really want to curate

[12:59](https://www.youtube.com/watch?v=21tuT-e4NVo&t=779s) golden examples um that you can specify

[13:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=782s) as this is what good looks like and

[13:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=784s) throughout throughout the cycle, the the

[13:06](https://www.youtube.com/watch?v=21tuT-e4NVo&t=786s) the definition of what good looks like,

[13:08](https://www.youtube.com/watch?v=21tuT-e4NVo&t=788s) what are my policies, what are my

[13:10](https://www.youtube.com/watch?v=21tuT-e4NVo&t=790s) standards, the more you can actually put

[13:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=793s) that as a context to the agent, the

[13:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=795s) better the outcome is going to be. And

[13:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=798s) and and the benefit of doing it

[13:19](https://www.youtube.com/watch?v=21tuT-e4NVo&t=799s) throughout the process is that you don't

[13:21](https://www.youtube.com/watch?v=21tuT-e4NVo&t=801s) sit at the end of it and look at

[13:23](https://www.youtube.com/watch?v=21tuT-e4NVo&t=803s) something that's suboptimal and say,

[13:24](https://www.youtube.com/watch?v=21tuT-e4NVo&t=804s) "Oh, but this did not pass X quality

[13:26](https://www.youtube.com/watch?v=21tuT-e4NVo&t=806s) gate or Y quality gate." And hence the

[13:29](https://www.youtube.com/watch?v=21tuT-e4NVo&t=809s) the the push that we're bringing um with

[13:31](https://www.youtube.com/watch?v=21tuT-e4NVo&t=811s) a lot of our clients then comes down to

[13:34](https://www.youtube.com/watch?v=21tuT-e4NVo&t=814s) breaking down at each check uh

[13:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=816s) checkpoint um all the way from

[13:38](https://www.youtube.com/watch?v=21tuT-e4NVo&t=818s) generating PRDS to what good uh code

[13:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=821s) looks like is it maintainable is it

[13:43](https://www.youtube.com/watch?v=21tuT-e4NVo&t=823s) something that's not complex is it

[13:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=825s) something that can actually u merge well

[13:48](https://www.youtube.com/watch?v=21tuT-e4NVo&t=828s) with the rest of the branches these are

[13:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=830s) the kind of uh rules that you would want

[13:52](https://www.youtube.com/watch?v=21tuT-e4NVo&t=832s) to encode in the agents that are

[13:53](https://www.youtube.com/watch?v=21tuT-e4NVo&t=833s) supporting you across across the PDLC

[13:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=837s) Um, one interesting phenomenon that

[14:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=840s) we're also seeing is that that the build

[14:03](https://www.youtube.com/watch?v=21tuT-e4NVo&t=843s) and test the one the two blocks that you

[14:05](https://www.youtube.com/watch?v=21tuT-e4NVo&t=845s) see highlighted because there's a lot of

[14:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=847s) acceleration because those those are

[14:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=849s) hero use cases where we're seeing a lot

[14:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=851s) of adoption um while the the time to do

[14:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=855s) those two parts of PDLC there's

[14:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=858s) compression in those two stages.

[14:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=860s) Interestingly then the bottlene

[14:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=862s) bottleneck is shifting towards the

[14:23](https://www.youtube.com/watch?v=21tuT-e4NVo&t=863s) upfront part which is how fast do you

[14:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=865s) also write the requirements and what are

[14:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=867s) the ways in which you do it downstream

[14:30](https://www.youtube.com/watch?v=21tuT-e4NVo&t=870s) which is ultimately how frequently can

[14:32](https://www.youtube.com/watch?v=21tuT-e4NVo&t=872s) you release and very interestingly

[14:34](https://www.youtube.com/watch?v=21tuT-e4NVo&t=874s) sideways and I'll talk just a little bit

[14:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=876s) more about it as well but the upstream

[14:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=879s) piece comes down to connecting your

[14:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=881s) agents to your environment to your

[14:43](https://www.youtube.com/watch?v=21tuT-e4NVo&t=883s) enterprise context giving them the logs

[14:46](https://www.youtube.com/watch?v=21tuT-e4NVo&t=886s) the customer logs the emails whatever

[14:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=887s) you can feed in uh but then also So uh

[14:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=890s) equipping the the connection back to

[14:53](https://www.youtube.com/watch?v=21tuT-e4NVo&t=893s) what build has to be done. Similarly for

[14:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=896s) release really mapping out what are your

[14:58](https://www.youtube.com/watch?v=21tuT-e4NVo&t=898s) enterprise requirements as it relates to

[14:59](https://www.youtube.com/watch?v=21tuT-e4NVo&t=899s) release and planning for it up front. Um

[15:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=902s) and and being able to bring acceleration

[15:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=904s) in that part is important. The sideways

[15:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=907s) one is interesting because we see a lot

[15:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=909s) of organizations which solve the the the

[15:12](https://www.youtube.com/watch?v=21tuT-e4NVo&t=912s) pieces of puzzle through and through and

[15:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=913s) you would see agents across the PDLC but

[15:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=916s) then especially in enterprise context

[15:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=918s) there are so many processes there are so

[15:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=920s) many procedures for example when we were

[15:23](https://www.youtube.com/watch?v=21tuT-e4NVo&t=923s) creating a customerf facing uh

[15:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=925s) application for uh for one of the recent

[15:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=927s) banks that we worked with they had rules

[15:30](https://www.youtube.com/watch?v=21tuT-e4NVo&t=930s) specific to the color scheme that had to

[15:32](https://www.youtube.com/watch?v=21tuT-e4NVo&t=932s) be used and whether a colorblind person

[15:34](https://www.youtube.com/watch?v=21tuT-e4NVo&t=934s) can actually click on one button forces

[15:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=936s) out there and really understand that and

[15:38](https://www.youtube.com/watch?v=21tuT-e4NVo&t=938s) in the traditional context you would

[15:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=939s) ultimately have some person then running

[15:42](https://www.youtube.com/watch?v=21tuT-e4NVo&t=942s) around to that team and sitting down

[15:43](https://www.youtube.com/watch?v=21tuT-e4NVo&t=943s) with that team and really understanding

[15:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=945s) what are those requirements but these

[15:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=947s) are the kind of bottlenecks that we

[15:48](https://www.youtube.com/watch?v=21tuT-e4NVo&t=948s) start organizations see emerge. So also

[15:51](https://www.youtube.com/watch?v=21tuT-e4NVo&t=951s) mapping out out what are your parallel

[15:53](https://www.youtube.com/watch?v=21tuT-e4NVo&t=953s) teams uh risk compliance governance

[15:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=957s) design all of those requirements also

[15:59](https://www.youtube.com/watch?v=21tuT-e4NVo&t=959s) have to be encoded into the agents as as

[16:01](https://www.youtube.com/watch?v=21tuT-e4NVo&t=961s) you think about this acceleration end to

[16:03](https://www.youtube.com/watch?v=21tuT-e4NVo&t=963s) end.

[16:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=967s) All right maybe one one one more thing

[16:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=969s) before we uh need to start wrapping up

[16:10](https://www.youtube.com/watch?v=21tuT-e4NVo&t=970s) here. I think a lot um one big area that

[16:14](https://www.youtube.com/watch?v=21tuT-e4NVo&t=974s) is um you know still a work in progress

[16:17](https://www.youtube.com/watch?v=21tuT-e4NVo&t=977s) I think is around uh measurement and and

[16:20](https://www.youtube.com/watch?v=21tuT-e4NVo&t=980s) and thinking through how do we think

[16:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=982s) about impact uh when we do all of this

[16:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=985s) right so we're we're we're investing

[16:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=987s) we're using up tokens we're getting new

[16:29](https://www.youtube.com/watch?v=21tuT-e4NVo&t=989s) tools we're retraining people and then

[16:32](https://www.youtube.com/watch?v=21tuT-e4NVo&t=992s) how do we know if it's if it's working

[16:33](https://www.youtube.com/watch?v=21tuT-e4NVo&t=993s) or not right and and there still there's

[16:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=996s) still quite a big gap in in this area

[16:40](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1000s) between like the actual the adoption of

[16:42](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1002s) AI and and so on versus uh the

[16:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1005s) organizations that feel confident that

[16:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1007s) they're measuring the right things and

[16:49](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1009s) that they have a good handle on what

[16:51](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1011s) what the output is. I think this is a

[16:54](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1014s) there is no I mean uh there's no quick

[16:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1017s) quick answer here like this has been you

[17:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1020s) know a perennial topic I would say in

[17:01](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1021s) software development for as last as long

[17:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1024s) as I can remember at least I mean been

[17:06](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1026s) in this space for for 20 plus years and

[17:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1029s) and so I mean it often comes down to

[17:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1031s) practically what what our clients are

[17:12](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1032s) doing is is actually you know is

[17:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1035s) measuring a lot of the things that are

[17:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1036s) not that are not new and then starting

[17:19](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1039s) to add in I think I have do have a

[17:21](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1041s) couple of clients who are using now AI

[17:23](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1043s) in some really interesting ways to also

[17:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1045s) think about impact. So can you use AI to

[17:28](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1048s) score the value of what you are building

[17:30](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1050s) to actually figure out the intent and

[17:33](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1053s) and starting to see like what you want

[17:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1056s) to do is is use your tokens invest your

[17:39](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1059s) resources in the things that are are

[17:40](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1060s) driving the the most value which sounds

[17:43](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1063s) very obvious when you say it but

[17:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1065s) incredibly actually incredibly hard to

[17:47](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1067s) do. Um, and and I think this is one

[17:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1070s) where uh really in the next few months I

[17:53](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1073s) think we're going to see uh a lot a lot

[17:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1076s) happen on this front because I'm I'm

[17:58](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1078s) starting to see this in in some of my

[17:59](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1079s) tech clients already. Um that will

[18:03](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1083s) really help like fig help uh

[18:05](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1085s) organizations figure out where to you

[18:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1087s) know where to put their effort and and

[18:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1089s) when they're getting value. I think the

[18:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1091s) the other thing just very pragmatically

[18:14](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1094s) that we're seeing being very helpful

[18:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1096s) links a little bit to the the team size

[18:18](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1098s) point that we were making making

[18:19](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1099s) earlier. I've several clients that

[18:22](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1102s) basically you know you reduce you reduce

[18:24](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1104s) your pod size to something that is half

[18:26](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1106s) or less than half of what it is today uh

[18:29](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1109s) and you create twice as many teams and

[18:31](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1111s) if you just think about the these teams

[18:33](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1113s) as still in in some ways the same teams

[18:35](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1115s) as before. So as engineering leaders you

[18:37](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1117s) you have a mental math thing this is uh

[18:40](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1120s) three teams for eight weeks or something

[18:42](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1122s) like that. If you in the short term just

[18:44](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1124s) keep thinking like that but the teams

[18:46](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1126s) are half the size uh you see a ton of

[18:49](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1129s) acceleration right and so that is almost

[18:51](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1131s) the little like cheat code in the near

[18:54](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1134s) term to to get some productivity but

[18:56](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1136s) that is obviously something that you

[18:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1137s) need to get more sophisticated uh over

[19:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1140s) time.

[19:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1142s) All right. So, so um maybe in uh you

[19:05](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1145s) know to to wrap this up, I know we've

[19:07](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1147s) only got 20 minutes or so, so we've

[19:09](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1149s) we've hit on a number of things. Uh we

[19:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1151s) will we will be here afterwards as well.

[19:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1153s) So, we would of course love to engage

[19:14](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1154s) with you on on more of these things that

[19:16](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1156s) we see as patterns that work. I think

[19:19](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1159s) this is, you know, getting real value

[19:21](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1161s) from AI in uh in software development is

[19:25](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1165s) as with many things, it's it's about

[19:27](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1167s) getting a 100 different things, right?

[19:29](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1169s) And doing it in a a reasonably

[19:31](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1171s) coordinated uh fashion, right? It's not

[19:34](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1174s) it's not changing one thing or putting

[19:36](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1176s) in a new tool and you're going to see

[19:37](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1177s) this happen. And that is both the the

[19:41](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1181s) challenge, but if you the good news now

[19:43](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1183s) is if you put the effort in and and do

[19:45](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1185s) this, we're seeing some some real major

[19:48](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1188s) improvements. Whereas in the past, you

[19:50](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1190s) may have only seen, you know, things you

[19:52](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1192s) work for a year and it gets 20 20%

[19:54](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1194s) better. Here is we're seeing 2x, 3x and

[19:57](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1197s) and beyond uh type improvements on on

[20:00](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1200s) many metrics in a relatively short

[20:02](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1202s) amount of time. Right? So I'm I'm really

[20:04](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1204s) optimistic. We're starting to see this

[20:06](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1206s) in in the data and I think things are

[20:08](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1208s) really starting to happen. So, um you

[20:11](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1211s) know, go go out there and and and do

[20:13](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1213s) more of this and and we'll we'll love to

[20:15](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1215s) hear how it goes. So, thank you so much

[20:17](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1217s) for having us and have a great rest of

[20:19](https://www.youtube.com/watch?v=21tuT-e4NVo&t=1219s) the day. Thank you.
