AI adoption works better when developers use it inside their IDE on real brownfield tasks, with deliberate context and model selection.
2
Teams should encode engineering practices in instruction files and shared knowledge bases, then document and share failures so the whole group learns.
3
Autonomous agents can handle bounded issues, reviews, tests, and documentation when they work in isolated branches and every change still passes human review and CI.
Summary
Jon Peck explains how organizations can introduce AI into everyday DevOps work without treating it as a code-generation shortcut. He recommends starting with developers working inside an AI-enabled IDE on existing applications, where they can learn how to shape prompts, select models, narrow context, and review or revert changes. Teams can encode their standards in Copilot instruction files and make internal patterns available through shared knowledge bases. Peck also covers governance, including privacy controls, excluded files, provider guarantees, and organization-wide policies. The largest early gains may come outside production coding, especially in planning, security reviews, test generation, deployment files, and documentation. He describes autonomous workflows for pull request summaries, code review, and issue assignments, with agents isolated on branches and protected environments. MCP connections can let agents work across GitHub and other systems without constant context switching.
AI gains depend on efficient workflows, not code volume
Peck says language models can produce large amounts of code, so the useful measure is whether teams deliver more feature points in the same period. In the best cases he has seen, teams reach up to 1.5 times as many feature points, while averages in most companies are closer to 30% improvement. He also reports more successful builds because existing tests catch problems earlier when people use AI. Developer happiness has improved as well. These results frame AI adoption around delivery and feedback from the existing DevOps pipeline, rather than counting generated lines of code.
Developers should learn AI on brownfield work inside the IDE
Peck advises teams to stop relying on a separate chat window and copy-pasting responses into an editor. An integrated IDE makes it easier to provide focused context, iterate, and reduce exposure. He recommends starting with real work on existing applications, such as changing a dependency version or creating tests for an existing data source. Greenfield projects can be fun, but they do not teach the daily patterns most developers need. Working on a brownfield codebase helps people learn how to shape prompts and choose the files and context that belong in each request.
Model choice and agent mode make context management practical
Peck says automatic model orchestration is not yet reliable enough to always choose correctly. Developers should select a fast, lower-cost model for simple responses and a reasoning model when exploring a problem deeply. Agent mode helps with both new and existing projects. For greenfield work, he first asks the agent to draft a specification in a README, then refines the technologies, file structure, API examples, and other details before asking it to build. For brownfield work, he limits the agent to selected folders and settings files. The agent can produce a plan, accept corrections, and be reverted when it takes the wrong path.
Instruction files and knowledge bases carry team practice into AI work
Team documentation remains necessary when AI enters the workflow. Peck describes GitHub's copilot-instructions.md file in the repository's .github folder as a place to record linting rules, model-access patterns, and checks for recurring problems. Leads and managers need to revise it when the team changes its practices, then commit it so everyone works from the same guidance. Copilot Enterprise knowledge bases provide another way to expose institutional knowledge. Teams can collect repositories that show accessible frontend patterns, Python machine learning practices, or internal API usage, then attach the relevant named knowledge base while working on code.
Teams learn faster when failures become shared documentation
Peck asks organizations to make it acceptable for developers to be wrong, ask questions, and report failed AI interactions. Someone who finds a model behaving badly in a particular context should post the problem in Slack or team chat, especially when another teammate may know the solution. Once resolved, the result should move into a central guide, a repository, or a shared knowledge store. That creates a record of the problem and its fix. He also recommends monitoring how people use their AI tools, including Copilot metrics or internal usage data, so hesitant developers and people who lack access to useful patterns can receive help.
The biggest early gains may come from work around coding
Peck describes several areas where AI can reduce work before and after implementation. During planning, it can help explore technologies, infrastructure, and the broad shape of a feature or product. For security, it can scan a large codebase for bad dependencies, insecure patterns, and issues such as cross-site scripting. Test generation is another strong use case: developers can provide modules, JSON examples, database access through MCP, and a testing framework to produce a usable skeleton. Models can also draft GitHub Actions and Terraform files for deployment. Documentation may produce the largest speed gain, from API specifications and executive summaries to usage examples and Mermaid workflow diagrams.
Governance needs privacy controls, exclusions, and organization-wide policy
Before teams send code to an AI service, Peck says organizations should check proxies, sanitization, provider guarantees, and whether submitted data is reused for training. He gives GitHub's enterprise indemnification and opt-in tracking as examples of provider commitments, and says GitHub does not retrain on enterprise data. Repositories can exclude secrets and other sensitive files from Copilot context. Organization-level policies can also control access to new features and models, avoiding a situation where every repository maintainer has to manage the same settings separately. The talk treats governance as a practical operating layer around daily AI use.
Autonomous agents need isolation and a human approval path
Peck separates semi-autonomous IDE agents from workflows that run with less supervision. Automation should be used where it saves time, with a human involved in the process. In GitHub's model, an autonomous agent works on a new branch inside a protected environment, leaving the main branch and existing environments untouched. It can generate a pull request description, review an existing pull request, or take a well-scoped issue and produce a branch and proposed pull request. People can reject the result, refine the issue, comment on the pull request for another change, or run normal CI/CD and merge it. Suggestions are presented for acceptance or rejection rather than injected automatically.
MCP lets agents act across GitHub and connected systems
Peck presents MCP servers as a way to give agents access to tools outside the immediate editor. In VS Code, developers can choose servers from the Model Context Protocol repository based on their workflow and technologies. GitHub's MCP server can let an agent create a branch, make a sensible commit, open a pull request, and assign an approver after completing code changes. Copilot Enterprise can also configure MCP connections at the repository level for agentic interactions such as issue assignments. That allows an agent to reach other systems while completing work, instead of requiring the developer to leave the current workflow and use separate web APIs.
"Make it okay to ask questions and admit your failures and bring them to the team because we're all in learning mode here."10:34
Who should watch
You are responsible for introducing Copilot or another AI coding tool to a team and need practices for prompts, context, model selection, and review.
Your organization has useful internal APIs, coding standards, or examples that AI tools cannot access without deliberate curation.
You want to assign bounded development work to agents while preserving branch protection, human review, and normal CI/CD checks.
