Become an Epic Product Engineer

The Future of the GitHub Product

· Summarized

Share this episode
Anyone with this link can open it.
Share Link
Start at 0:00

Key takeaways

  • AI should return implementation and verification time to customer conversations, ideation, collaboration, and choosing the right product work—not merely produce more code.
  • The boundary between software engineering and product management is situational, but engineers benefit from understanding customers and traditionally separate areas of product work.
  • Small teams gain an advantage by traversing a fast learning loop, measuring business outcomes rather than treating PR counts or lines of code as the goal.
  • Teams should track quality, incidents, cost, delivery time, and focused versus unfocused work, while reducing repetitive toil through automation.
  • Product engineers should state their intent, constraints, and desired outcomes so systems such as Copilot Fusion can select and orchestrate models and agents.

Summary

CoreAI is building the system for AI-native development

Jay Parikh explains that Microsoft’s CoreAI team supports everything AI-powered and AI-native developers need: tools, systems, infrastructure, primitives, platforms, and the surrounding ecosystem. He says AI is changing software development as an entire system, not merely through one model or tool; future applications will be built, deployed, governed, and secured differently. Kent adds that better agents create both stronger security capabilities and a greater need for secure agents, while product engineers can currently gain leverage by designing the primitives agents combine to reach an outcome.

Implementation time should move toward customers and outcomes

Kent describes having two “existential crises” as a software implementer before shifting toward product engineering, where deciding what to build matters more than manually typing code. Jay says AI can remove toil such as data analysis, information gathering, and integrations, giving developers time for ideation, creation, collaboration, customer conversations, and “picking right.” He argues that the shorter path from intent to outcome should be measured by whether a feature improves the business, not simply by how much implementation or verification was completed.

The engineer–product manager boundary depends on the product

When Kent asks whether engineers are becoming product managers, Jay rejects a fixed answer. The division depends on the product, industry, and company: enterprises may still benefit from distinct expertise in pricing, packaging, marketing, architecture, security, observability, and infrastructure, and those experiences do not blur overnight. At the same time, Jay encourages engineers to become curious about traditionally separate roles and get closer to customers, because understanding who a system is for helps them build better products and deliver more value.

Small teams compound learning faster than large handoffs

Jay says small teams that can move quickly create a faster learning loop than competitors: the smaller and faster the loop, the sooner the team learns, and that learning compounds. He frames agentic software delivery around velocity, intelligence, and quality, but warns that velocity cannot mean counting pull requests alone; teams must connect completed work to business outcomes. Kent and Jay agree that output such as code matters only insofar as it produces the intended result, improves the product, or moves the business forward.

GitHub capacity planning must track rising usage and efficiency

Kent points out that GitHub’s scaling challenge is not only more contributors but more activity per person, requiring a rethink of infrastructure allocation. Jay calls capacity planning imprecise because new technologies and models can suddenly change demand, so GitHub watches usage cohorts and other signals for early warnings, combines them with forecasting, and continually improves efficiency. Prompt caching, gateway optimization, and reduced CPU use in Actions can free capacity for more features or load. He also anticipates differentiated free, basic, and enterprise offerings for different usage needs.

Metrics should expose toil, and Fusion should choose the models

Jay says activity metrics such as lines of code and pull requests were useful when introducing new tools, because teams first needed broad adoption and experience, but quality requires measures such as PR velocity divided by incident rate, cost, time from a bug or idea to delivery, and business impact. CoreAI also tracks focused versus unfocused developer time and repetitive toil. On Copilot Fusion, Jay says users should express priorities such as a budget limit or maximum quality rather than choose models themselves; Fusion can orchestrate patterns such as signal, cascade, and critique across models and agents.

The homework: raise ambition and wire outcomes into the system

For listeners, Jay assigns two kinds of homework. First, raise the ambition level: try something bigger, bolder, or faster, experiment with different tools and approaches, and find the edge of what is possible. Second, define explicit outcome metrics, distinguishing leading from lagging indicators, and connect them to dashboards and agents. Kent adds that agents can help with decisions and preserve project context, but people remain accountable for ownership and the outcomes they choose.

Show notes

If AI handed you back hours of implementation time and you're not sure where to spend it, this episode is for you. Kent talks with Jay Parikh - Executive Vice President of CoreAI at Microsoft - about putting that time into customers, ideas, and outcomes instead of more output.

They cover where the line between engineer and product manager is (and isn't), why small teams win the learning loop, activity metrics vs outcome metrics, tracking focus time and toil, capacity planning at GitHub scale, and why Copilot Fusion means you shouldn't have to pick a model.

  • (00:00) - Meet Jay Parikh and Microsoft CoreAI
  • (01:16) - Where software engineers fit now
  • (03:33) - Spend saved time on outcomes and customers
  • (05:12) - Product engineer vs product manager
  • (06:47) - Small teams, faster learning loops
  • (08:30) - Capacity planning at GitHub scale
  • (11:41) - Activity metrics vs outcome metrics
  • (14:38) - Tracking focus time and toil
  • (15:44) - Copilot Fusion: stop picking models
  • (18:32) - Agents that manage the project
  • (19:00) - Homework: raise your ambition, measure outcomes

Jay Parikh leads CoreAI at Microsoft, the organization building the tools, platform, and infrastructure for AI-native developers, including GitHub. Kent caught up with him the day of his GitHub Universe keynote.

The through-line is outcomes over output. When agents take on more of the implementation and verification, Jay wants that time to go into ideation, creation, collaboration, and "picking right" - and then into checking whether the feature actually moved the business. The line between software engineer and product manager is situational, not fixed, but getting closer to the customer is all upside for engineers.

They talk about small teams that traverse a faster learning loop than competitors, why activity metrics (lines of code, PR counts) were useful for getting people moving but aren't the goal, dividing PR velocity by incident rate, measuring focus time vs unfocused time and toil across CoreAI, capacity planning when volume per person keeps climbing, and Copilot Fusion and Copilot projects: express your intent and budget, and let the system orchestrate the models and agents.

Homework: whatever level of ambition you have, raise it. Then define explicit outcome metrics (leading and lagging) and wire them into your dashboards and your agents.

Homework

  • Whatever level of ambition you have with these tools, raise it: try something bigger, bolder, and faster than you think you're ready for.
  • Try different tools and different ways of doing the work to find the edge.
  • Define explicit outcome metrics for what you're building, and know which are leading and which are lagging.
  • Wire those outcome metrics into your dashboards and your agents so the whole learning loop runs faster.

Resources

Guest: Jay Parikh

Host: Kent C. Dodds

Follow this show on AudioBrevity and new episodes get summarized for you. Create a free account

Couldn't load the audio. A blocker may be stopping the show's tracking links. Open the file