← All speakers

Jon Peck

Conference affiliation: GitHub · 2025

Jon Peck is a senior product marketing manager at Evinced whose work connects AI-assisted development with accessibility testing. Previously, he helped establish GitHub’s Enterprise Advocacy team in the Americas, teaching organizations to give coding agents explicit requirements, shared engineering conventions and tasks whose results people could review.

On this page

Jon has developed software since the late 1990s and studied computer science at Cornell University. His earlier career included work with Cornell, Massachusetts General Hospital and Algorithmia. At Algorithmia, he worked on serverless machine-learning services and production deployment. He also developed hands-on training for deploying machine-learning models as microservices, explaining how to make models available to other software through services.

He joined GitHub in 2020, working in its Executive Briefing Center before moving into technical advocacy and enterprise developer relations. His guide to collaboration-ready repositories addressed the conditions that let people contribute: a clear project purpose, documented ownership and understandable contribution rules. His later work with coding agents applied those concerns to software that could propose changes as well as to the people reviewing them.

Learning on existing software

Jon advocates brownfield AI adoption: learning to use coding assistants by improving applications that already exist. An ORM migration, missing tests or incomplete documentation gives a developer a bounded task and a recognizable standard for success. In his approach to organizational AI adoption, he asks whether generated code produces useful engineering outcomes and gives planning, testing and documentation attention alongside implementation.

His comparison of models inside GitHub Copilot treats model selection as a task-dependent choice involving speed, completeness and output quality. In his teaching, a quick, inexpensive response and a deeper investigation call for different choices; project context and custom instructions also shape the result.

Jon is willing to discard an agent’s work. If hundreds of changes head in the wrong direction, his advice is to revert them, refine the request and try again, keeping commits at points where the application works. He also asks teams to share failed approaches and record their solutions in a common guide, so the next developer can learn from the problem.

Giving agents the team’s working knowledge

Several practices make that approach concrete:

  • Record architectural decisions as they happen. Jon treats shared Copilot instructions as a responsibility for technical leads. When a team chooses dependencies, changes a coding pattern or makes an architectural decision, that decision should enter the instructions. Developers should not have to reconstruct the team’s standards in every prompt. He contributed this point while working with Christopher Harrison in their hands-on Copilot workshop.
  • Choose tools with appropriate permissions. In his PostgreSQL MCP demonstration, an agent retrieves the database schema and table contents, writes a local mock-data file and uses it to build tests. Jon deliberately chooses a read-only server to prevent accidental database changes. When the agent does not consistently select the integration itself, he explicitly names the PostgreSQL tool in his requests.
  • Keep useful documentation beyond the conversation. A detailed README can specify an application’s structure, environment, database and endpoints before implementation begins. Jon also asks agents to maintain a changelog, giving him an account of their intermediate work alongside Git history. His Copilot Chat to Markdown project turns assistant conversations into reusable Markdown.

His guide to turning issues into pull requests extends these practices to background coding agents: specify the task and acceptance criteria, let the agent propose changes on a branch, then review the result and run the existing CI/CD checks. Detailed instructions help communicate expectations; human review, tests and security checks still determine whether a change should merge.

Testing whether generated interfaces are usable

At Evinced, Jon examines accessibility defects in AI-generated software. His comparison of three models across three frontend approaches found accessibility defects in all nine generated applications. That result gives his argument a concrete scope: each of those outputs required further accessibility work despite the models’ ability to generate interfaces.

His work on design-to-engineering handoffs follows accessibility requirements into implementation, where they can disappear between a design and the resulting component. He emphasizes executable checks for keyboard interaction, component states and regressions—specific behaviors a team must preserve as it changes the software.

Read the topics behind these talks

4 conference talks

Loading more talks and highlights…

References