💻 Code Generation
AI coding tools and agents. Cursor, Devin, Copilot internals, SWE-bench, agentic refactoring, repo-scale understanding.
The workflow
flowchart LR
A[Task / prompt] --> B[Retrieve repo context<br/>files + symbols]
B --> C[LLM emits diff<br/>or whole file]
C --> D[Execute / test<br/>in sandbox]
D --> E{Pass?}
E -->|No| F[Self-repair<br/>read error → patch]
F --> C
E -->|Yes| G[PR / commit<br/>+ review]
Coding agents are the first place where AI delivers full economic value. The eval is "did the test pass?"
Key takeaways
Videos (130)
"Software Fundamentals Matter More Than Ever" — Matt Pocock
AI coding works best when paired with classical software discipline — shared design concepts, ubiquitous language, and resistance to entropy.
Full Walkthrough: Workflow for AI Coding — Matt Pocock
Treat LLM context as a finite 'smart zone' and structure coding workflows (small tasks, looping plans, compaction) to stay inside it.
No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer
Advanced context engineering — small, intentional, reviewed context windows — beats raw model power for complex brownfield coding work.
The Infinite Software Crisis – Jake Nations, Netflix
AI codegen optimizes the mechanics Brooks said were never the bottleneck, so the only sustainable fix is to keep doing the hard human work of designing simple, untangled systems.
Does AI Actually Boost Developer Productivity? (100k Devs Study) - Yegor Denisov-Blanch, Stanford
Rigorous private-repo measurement shows AI coding tools yield a real but modest ~15–20% net productivity gain, largely offset by rework on AI-generated code.
Building pi in a World of Slop — Mario Zechner
Coding-agent harnesses should be tiny, observable, and self-modifiable so the model — already trained as a coding agent — owns its own context.
Claude Code & the evolution of agentic coding — Boris Cherny, Anthropic
Coding models are advancing faster than coding products, so Anthropic ships Claude Code as a minimal unopinionated surface to let users discover the right agentic UX.
Understanding is the new bottleneck — Geoffrey Litt, Notion
Use AI to teach you the systems it changes so faster coding does not erode your ability to shape the project.
Harness Engineering: How to Build Software When Humans Steer, Agents Execute — Ryan Lopopolo, OpenAI
Treat agents as infinitely-parallel implementers and invest your time in writing guardrails and persona-oriented docs that make 'a good job' legible to them.
Defying Gravity - Kevin Hou, Google DeepMind
Antigravity reframes the IDE around an agent manager that orchestrates editor and browser agents, leveraging Gemini 3's longer-horizon multimodal tool use.
How Claude Code Works - Jared Zoneraich, PromptLayer
Claude Code works because it strips scaffolding and trusts a tool-calling-tuned model in a simple agentic loop — the lesson is delete complexity, not add it.
Everything we knew about software has changed — Theo Browne, @t3dotgg
Expand task ambition and reconsider inherited workflows to benefit from increasingly capable coding agents.
From Vibe Coding To Vibe Engineering – Kitze, Sizzy
Embrace AI-assisted coding but layer engineering practices on top so you graduate from vibe coding's gambling loop to disciplined vibe engineering.
Vibes won't cut it — Chris Kelly, Augment Code
AI accelerates code generation but production software engineering — changing systems safely at scale — still requires human judgment, context, and rigorous practices.
"The engineer of the future is the person who is able to choose what is worth doing." — Addy Osmani
Focus engineering judgment on evidence-backed decisions and ownership of production outcomes.
How Windsurf writes 90% of your code with an Agentic IDE - Kevin Hou, Windsurf
Tight editor-agent integration via a shared action timeline is what lets Windsurf write the majority of code while keeping users in flow.
Agentic Engineering: Working With AI, Not Just Using It — Brendan O'Leary
Productivity gains from AI coding come from explicit context engineering and treating agents like fast but judgment-poor juniors you must direct.
From AI-Assisted to AI-Native: Building a Frontier Development Team — Clare Liguori, AWS
Large agent-assisted productivity gains require deliberate workflow and codebase changes, with attention to how results are measured.
The Golden Age of AI Engineering — Alexander Embiricos & Romain Huet & Peter Steinberger, OpenAI
Build agent workflows that span the whole job while preserving engineers' ability to inspect, steer, and make product decisions.
AI Engineering at Jane Street - John Crepezzi
For obscure internal languages, custom fine-tuning on workspace snapshots + build-state transitions beats off-the-shelf coding models.
Harness Engineering is not Enough: Why Software Factories Fail — Dex Horthy, HumanLayer
Treat unattended software factories cautiously in complex codebases because harnesses cannot eliminate every model and verification limitation.
2026: The Year The IDE Died — Steve Yegge & Gene Kim, Authors, Vibe Coding
The future of coding tools is swarms of specialized agents orchestrated through a UI, not a single muscular agent inside an IDE.
Making Codebases Agent Ready – Eno Reyes, Factory AI
The bottleneck for agent productivity in enterprises is automated-validation rigor in the codebase, not which coding agent you buy.
Amp Code: Next Generation AI Coding – Beyang Liu, Amp Code
Effective coding agents come from curated tools, dedicated subagents for search/reasoning, and a review UI — not from piling on MCP servers.
Collaborative AI Engineering: One Dev, Two Dozen Agents, Zero Alignment — Maggie Appleton, GitHub
Coding agents have collapsed implementation cost so alignment must become continuous and multiplayer — not a PR-time afterthought.
Spec-Driven Development: Agentic Coding at FAANG Scale and Quality — Al Harris, Amazon Kiro
Spec-driven development with EARS requirements and property-based testing gives agentic coding a verifiable throughline from intent to shipped code.
Self Coding Agents — Colin Flaherty, Augment Code
An AI coding agent given basic process and tool primitives can write the bulk of its own codebase, including features, tests, and self-profiling optimizations.
The AI Skill I Rely On Daily — Priscila Andre de Oliveira, Sentry
A reusable code-comprehension skill can deliver substantial daily value by making unfamiliar and changing systems easier to understand.
OpenAI Codex Masterclass — Vaibhav Srivastav & Katia Gil Guzman
Codex is positioned as a full software-engineering teammate across surfaces, with sub-agents, work trees, and plugins as the new productivity primitives.
BDD, ADR, PRD, WTF: Capturing Decisions for Humans and AI Alike — Michal Cichra, Safe Intelligence
Make product intent durable and enforceable with linked decision records, executable behaviors, and automated feedback.
Building Cursor Composer – Lee Robinson, Cursor
Cursor Composer trades raw frontier-model intelligence for 4x speed by RL-training on a production-mirroring environment with custom MoE kernels.
The emerging skillset of wielding coding agents — Beyang Liu, Sourcegraph / Amp
Coding agents need a new operating mode (direct edits, oversight not approval, usage-based pricing, model-coupled scaffolding) — old chatbot intuitions actively hurt.
The State of AI Code Quality: Hype vs Reality — Itamar Friedman, Qodo
You don't break the AI productivity glass ceiling with better autocomplete — you break it with agentic, dynamically-learning quality workflows across the whole SDLC.
How Anthropic Builds: Lessons from Labs — Mike Krieger, Anthropic
Delegate ambitious outcomes while supplying the tools, verification loops, and rollout controls needed to reach them reliably.
Developer Experience in the Age of AI Coding Agents – Max Kanat-Alexander, Capital One
Make your codebase, tooling, and documentation match how the rest of the industry works so agents inherit decades of training-set fluency.
From Writing Code to Designing Systems: How the Developer Role is Changing — Chris Noring, Microsoft
Treat agent workflows and repository guardrails as core engineering work as implementation becomes increasingly delegated.
Building your own software factory — Eric Zakariasson, Cursor
Treat your codebase like a factory: structure for discoverability, add guardrails reactively, and invest in verifiable end-to-end checks.
Software Development Agents: What Works and What Doesn't - Robert Brennan, OpenHands
Coding agents become genuinely productive when you scope tasks tightly, sandbox aggressively, and treat the agent as the inner-loop coder while humans own architecture.
In the Land of AI Agents, the Verifiers Are King — Tariq Shaukat, Sonar
Embed verification into the generation loop so faster code production translates into maintainable, reliable software.
Loop Engineering from First Principles — Kyle Mistele, HumanLayer
Engineer coding loops around measurable targets and small verified changes so automation improves reviewability and system stability.
Devin 2.0 and the Future of SWE - Scott Wu, Cognition
Coding agents are scaling on a 70-day doubling curve; product strategy must re-baseline every model generation as Devin moves from migrations to multi-file feature work.
The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents
Judge loop automation by task boundaries, feedback quality, and engineering discipline rather than claims of effortless autonomy.
Your Coding Agent Should Do AI System Engineering — Ben Burtenshaw, Hugging Face
Pair coding agents with maintained examples, hardware benchmarks, and reusable distribution formats to make AI systems optimization practical.
Why Rust is the Ideal Language for Vibe-Coding — Daniel Szoke, Sentry
Choose language constraints that catch classes of agent mistakes automatically, rather than optimizing only for easy initial code generation.
Claude Fable, Claude Tag, and Anthropic's Culture — Cat Wu & Thariq Shihipar ft Simon Willison
More capable coding agents shift human effort toward product judgment and make persistent, collaborative automation a practical work surface.
Software Engineering Is Becoming Plan and Review — Louis Knight-Webb, Vibe Kanban
As coding agents take longer per run, your job collapses to planning and reviewing — invest in specs to amortize review cost across parallel agents.
Real World Development with GitHub Copilot and VS Code — Harald Kirschner, Christopher Harrison
Vibe coding maps to a maturity curve from YOLO prototyping to disciplined guardrails — VS Code + Copilot agent mode supports all three stages.
Rust is the language of the AGI - Michael Yuan
Rust's strict compiler turns 'hard to write' into a strong reward signal, making it the ideal target language when machines, not humans, are doing most of the coding.
The Making of Devin by Cognition AI: Scott Wu
Devin demonstrates that autonomous software engineers using human tooling (terminal, git, PRs) are the next phase beyond code-completion.
Beyond the Prototype: Using AI to Write High-Quality Code - Josh Albrecht, Imbue
Quality AI-generated code comes from synchronous prevention plus detection loops — plan, spec, lint, test, LLM-review — not from picking the smartest base model.
Building AI Agents with Real ROI in the Enterprise SDLC: Bruno (Booking.com) & Beyang (Sourcegraph)
Real enterprise AI-coding ROI comes from picking honest KPIs, training daily users, and giving agents deep codebase context for legacy migration work.
Replacing 12K LoC with a 200 LoC Skill — David Gomes, Cursor
Cursor replaced ~12K lines of worktree/best-of-N feature code with ~200 lines of markdown agent skills, demonstrating skills can collapse complex agent features.
Mergeable by default: Building the context engine to save time and tokens — Peter Werry, Unblocked
Reliable background coding agents need a real context engine — curated, relationship-aware organizational knowledge — not just RAG or MCP plumbing.
Dark Factory: OpenClaw Ships Faster Than You Can Read the Diff — Vincent Koc, OpenClaw
High-volume agent coding shifts engineering effort toward architecture, acceptance criteria, and deciding which changes belong in the product.
"Software engineering is not about writing code" — Benoit Schillings, Google DeepMind VP of Research
As code generation becomes cheaper, engineering value concentrates in specification, architecture, and managing system complexity.
Guide, Verify, Solve — Anirban Chatterjee, Sonar
Sustained AI coding productivity requires systematic quality verification matched to the application’s needs.
Recursive Coding Agents - Raymond Weitekamp, OpenProse
Reliable agent outcomes depend on how work and context are decomposed and verified, not only on model intelligence.
Fast Models Need Slow Developers — Sarah Chieng, Cerebras
Faster coding models make deliberate development and verification more valuable because unchecked errors can accumulate faster too.
Piloting agents in GitHub Copilot - Christopher Harrison, Microsoft
Treat GitHub Copilot like a pair programmer — readable code, clear instructions and explicit context matter more than clever prompting.
Codex, Behind the Harness — Dominik Kundel, OpenAI
A capable harness manages context and asynchronous actions explicitly while exposing reusable interfaces around the model.
Beyond Code Coverage: Functionality Testing with Playwright MCP — Marlene Mhangami, Microsoft
Use AI to accelerate behavioral testing and implementation while reserving deliberate effort for refactoring and code quality.
Vibe Engineering Effect Apps — Michael Arnaldi, Effectful
To make coding agents useful on undocumented libraries, drop the library repo straight into your project so the agent's code-focused training kicks in.
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Scale coding-agent adoption by investing in verifiable plans and shared engineering knowledge while addressing the human costs of the transition.
How to Generate Mergeable Code with a Context Engine — Peter Werry, Unblocked
Mergeable code requires organizational intent and historical constraints to reach agents in a focused, inspectable form.
Future-Proof Coding Agents – Bill Chen & Brian Fioca, OpenAI
Don't port prompts across models — match instructions to the model's trained habits, or use a co-developed model+harness like Codex.
How to Kill the Code Review — Ankit Jain, Aviator
Move review toward intent, behavioral evidence, and reusable checks while preserving the collaboration that line-by-line review previously supported.
Windsurf everywhere, doing everything, all at once - Kevin Hou, Windsurf
The next leap for AI coding tools is a shared human-AI timeline that lets parallel agents understand context and act without losing the user's intent.
The Era of Compound Engineering — Kieran Klaassen, Every/Cora
Capture your judgments and corrections as reusable knowledge so each completed task improves the next one.
Your Code Has Bugs. Lean4 Has Proofs: Formal Verification for Engineers — Varun Pant, AWS
Use carefully reviewed specifications and machine-checked proofs for critical properties, while distinguishing proved models from implementations tested against them.
Using Spec-Driven Development for Production Workflows - Erik Hanchett, AWS
Use reviewed specifications as durable guidance for coding agents, with context discipline and human accountability throughout implementation.
RL for Autonomous Coding — Aakanksha Chowdhery, Reflection.ai
Reinforcement learning with automated verifiers (tests, compilers) is the unlock for autonomous coding because correctness can be checked cheaply at scale.
Self Driving Products: Product Signals to Pull Requests — Joshua Snyder, PostHog
Turn observability into actionable changes by grouping signals around underlying problems and grounding agent investigation in product context.
fighting slop with slop — Vaibhav Gupta, Boundary
Replace exhaustive manual code reading with strong design review, architectural invariants, and continuous agent-driven testing.
Your Coding Agent Just Got Cloned And Your Brain Isn't Ready - Rustin Banks, Google Jules
Async cloud coding agents like Jules unlock parallel multitasking and multi-variation development, but require AI at both ends of the workflow to remain sane.
Vibe Coding with Confidence — Itamar Friedman, Qodo
CLI-based agentic workflows that fold review and testing into authoring are the path from vibe-coded prototypes to trustworthy enterprise software.
Building uReview, Uber’s Multi-Agent Code Review Engine — Will Bond & Ameya Ketkar, Uber
Automated code review scales best when actionable feedback, team context, and detailed operational measurements reinforce each other.
Ship Production Software in Minutes, Not Months — Eno Reyes, Factory
Agent-native development means standardizing how your org thinks so droids can ingest your context and orchestrate work across the whole software lifecycle.
Code Generation and Maintenance at Scale: Morgante Pell
Large-scale code migrations need static analysis + semantic search + agentic execution — vanilla embedding RAG retrieves too much irrelevant code to be useful.
AI powered entomology: Lessons from millions of AI code reviews — Tomas Reimers, Graphite
AI code review only works when comments stay in the 'LLM-can-catch AND human-wants-it' quadrant — measured by downvotes plus whether developers actually act on them.
Should AI Engineers Still Read Code in 2026? The Z/L Continuum — Alex Volkov, ThursdAI
Higher code-generation throughput makes deliberate review and engineering accountability more consequential.
Agents, codebases, and teams — Aditya Khandelwal, Amazon AGI Lab
Treat effective team use of coding agents as an organizational and harness-engineering responsibility.
Multiplayer agentic engineering — Arjun Singh, Superconductor
Make agent sessions shared, persistent, and visible across the places where teams already collaborate.
AI Agents for Performance: Ship Faster, Pay Less — Rajat Shah, Netflix
Ground performance agents in production profiles and matching source revisions so optimization starts from measured bottlenecks.
The Last Human Code Review: Building Trust in AI-Generated Code — Itamar Friedman, Qodo
Reliable automated code review requires shared organizational knowledge, consistent governance, and evidence humans can inspect.
Benchmarking Coding Agents on New vs Legacy Codebases — Denys Linkov, Wisedocs
Reassess refactoring workflows as agents improve, while measuring maintainability and correctness alongside execution speed.
How Building with AI Can Double the Throughput of Your Engineering Team — Brian Scanlan, Intercom
Large-scale AI productivity gains require a staffed organizational program, shared tooling, and company-specific context.
RLM: Recursive Language Models for Large Codebases - Shashi, Superagentic AI
Treat a large repository as structured data that an agent can query programmatically instead of loading it wholesale into context.
LLM codegen fails and how to stop 'em — Danilo Campos, PostHog
Fight LLM codegen hallucination by tool-calling fresh markdown docs into context — context windows are big enough that RAG isn't required.
The Cure for the Vibe Coding Hangover — Corey J. Gallon, Rexmore
Replace vibes with discipline — specs not prompts, atomic features, dependency-driven order, and executable tests before any agent writes code.
How to Improve your Vibe Coding — Ian Butler
Vibe coding only works with explicit rules, careful context management, and thinking models — naive setups generate alert fatigue from false positives.
GitHub Copilot: The World's Most Widely Adopted AI Developer Tool
Copilot has become a full-stack developer assistant — IDE completion, chat, PR summaries, knowledge-base Q&A — across every major IDE and SCM.
Your coding agent doesn't always follow your rules — Talha Sheikh, Checkout.com
Turn requirements into executable verification contracts so the user is no longer the only enforcement layer.
How We Built Zeta2: Training an Edit Prediction Model in Production — Ben Kunkle, Zed
Train specialized coding models with repaired teacher data, carefully filtered user outcomes, and production validation.
Welcome to AIE CODE - Jed Borovik, Google DeepMind
AIE CODE Summit positions AI coding as the single most important applied-AI problem and brings a focused, single-track audience together around it.
Building AI For All: Amjad Masad & Michele Catasta
Replit is bundling AI coding assistance plus inference (Model Farm) free to all users to ensure the next billion developers aren't gated from AI-enhanced programming.
Enhancing Quality and Security in CI: Gunjan Patel
Use CI's slack time as the venue for slow, deliberate AI passes (rename/comment/test/security) — Copilot does the fast thinking, GhostPilot does the slow thinking.
A Genius With Amnesia - Victor Savkin, Nx
Cross-repository context and persistent work history reduce the human effort required to coordinate coding agents.
GPT Web App Generator - 10,000 apps created in a month: Matija Sosic
Constraining the codegen target (Wasp + React/Node) and tiering GPT-4 planning with GPT-3.5 implementation produces cheap, reliable full-stack app generation.
The Many Ends of Programming - Ray Myers
Map AI's impact on programming across six scenarios (from extreme completion to garbage pile) instead of treating it as a binary apocalypse.
To the moon! Navigating deep context in legacy code with Augment Agent — Forrest Brazeal, Matt Ball
Augment Agent positions its proprietary context engine as the real differentiator for AI on legacy codebases — model quality matters less than what you feed it.
Content Is Code - Matt Palmer, Conductor
When code generation becomes cheap, organizational structure and careful maintenance become the bottlenecks for high-quality content.
ReviewDebt: a practical framework for scoring every pull request — Sachin Gupta, Ebay
Measure the verification burden of generated changes alongside coding speed to keep review debt visible.
Reverse engineering a Viking VOIP phone protocol with Claude Code — Boris Starkov, Eleven Labs
Coding agents can solve legacy integration problems by combining protocol exploration with observed traffic and validation.
The Code AI Maturity Model and What It Means For You: Ado Kukic
Code AI follows a six-level autonomy ladder from autocomplete to full SDLC ownership — most teams sit at L2-L3 today.
What Data from 20m Pull Requests Reveal About AI Transformation — Nick Arcolano, Jellyfish
Interactive coding tools are delivering measurable 2x throughput and faster cycles without quality regressions, while fully autonomous agents remain pre-production at most companies.
Supercharging developer workflow with Amazon Q Developer - Vikash Agrawal
Amazon Q Developer covers the full SDLC — CLI + IDE slash commands plus GitHub and AWS console integration — letting one developer hand off planning, testing, docs and deploy to the agent.
The Prompt is the Platform - Dominik Tornow, Resonate HQ
Agents can help design reliable systems when abstract specifications are connected to implementation through precise simulation feedback.
Prototyping as Leadership: How a CTO Ships with AI Agents — Hursh Agrawal, The Browser Company
Technical leaders can use well-contextualized autonomous runs to turn strategic judgment into working prototypes despite fragmented schedules.
Vision: Zero Bugs — Johann Schleier-Smith, Temporal
Aerospace shows zero-bug software is possible with N-version, formal-method, and process-driven engineering — a discipline AI-generated code increasingly needs.
Mastering Engineering Flow with Windsurf - Eashan Sinha, Windsurf
Windsurf bets that real productivity gains come from tracking implicit user intent and pairing agentic tool use with explicit workflows, not just better chat.
The AI Evolution: Mario Rodriguez, GitHub
GitHub Copilot's $100M+ ARR rests on UX (ghost text), latency engineering and Codex/GPT-3.5 — not just the model — and post-PMF success requires global infra and rigorous online evals.
Move Fast Break Nothing: Dedy Kredo
Reliable codegen needs a generator+critic pair: behavior-driven tests plus automated review flag the security and correctness issues humans miss.
Your agent is blindfolded — Johan Lajili, Poolside AI
Give coding agents the ability to observe and test the actual application so they can correct their own mistakes.
Copilots Everywhere: Thomas Dohmke and Eugene Yan
GitHub's bet is human-centric copilots that bridge issue-to-PR while keeping the developer in flow — augmentation, not autonomous replacement.
The Rise of the AI Software Engineer: Jesse Han
Morph's bet: combine static analysis + embeddings + graphs into a queryable code index that both retrieves context for any coding agent and generates fine-tuning data.
Develop at Idea Velocity - Jeffrey Lee-Chan, Snapchat
Persistent coordination, isolated coding workers, and strong feedback loops can reduce the friction between an idea and a working change.
Mentoring the Machine — Eric Hou, Augment Code
Engineers should treat coding agents like mentees — invest in teaching them the codebase so they absorb the firefighting that destroys deep work.
[Full Workshop] Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments
Move enterprises through yolo -> structured -> spectrum vibes by adding guardrails (workspace settings, popular stacks, auto-approval policies) without killing the creative speed.
How Coding Agents change Software Development Forever - Hailong Zhang
Effective coding agents are narrow, evaluation-grounded, and built on a shared agent-OS abstraction — not monolithic 'software engineer' bots.
Developing Taste in Coding Agents: Applied Meta Neuro-Symbolic RL — Ahmad Awais, CommandCode
Coding agents need a learned, inspectable 'taste' layer — meta neuro-symbolic preference modeling — to move beyond sloppy defaults and brittle rules files.
Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments - Harald Kirshner,
Enterprise vibe coding works when you graduate from YOLO mode to templates plus MCP-based tools that constrain agents to your stack and conventions.
Collaborating with Agents in your Software Dev Workflow - Jon Peck & Christopher Harrison, Microsoft
Treat GitHub Copilot as a pair programmer reading your code — better naming, comments, and explicit intent are still the highest-leverage prompt-engineering for it.
[Workshop from Microsoft] Github Copilot - The World's Most Widely Adopted AI Developer Tool
GitHub Copilot's effectiveness leans heavily on the context (open tabs, comments, examples) developers provide; chat unlocks broader code Q&A while business code stays out of training.
We Gave an Agent Production Code Access and Then Tried to Sleep at Night — Moritz Johner, Form3
Production patching agents should operate inside deterministic orchestration that limits edits and owns publication, verification, and escalation.
The Eyes Are The (Context) Window to The Soul: How Windsurf Gets to Know You — Sam Fertig, Windsurf
Coding agents that 'know you' rely on heuristics (user behavior) + hard evidence (codebase) plus relevance-first context retrieval — not bigger windows.
The Agent Awakens: Collaborative Development with Copilot - Christopher Harrison, GitHub
Treat GitHub Copilot like an AI pair programmer — clear code, clear intent, and pick the right mode from completions to autonomous coding agent.
Don't get one-shotted: Use AI to test, review, merge, and deploy code — Tomas Reimers, Graphite
Build AI-native outer-loop tooling (review, CI, merge, deploy) because the inner-loop speedup is creating a review bottleneck and security risk.
Unlocking AI Powered DevOps Within Your Organization — Jon Peck, GitHub
Roll out AI DevOps by training brownfield prompting habits, codifying team standards in copilot-instructions.md, and curating exemplar knowledge bases.
GitHub Next Explorations: Rahul Pandita
GitHub Next bets on staged exploration: code-completion is evolving to multi-location 'Next Edit Suggestions' and to full inner-loop task completion via Copilot Workspace.
GitHub's AI Powered Security Platform: Sarah Khalife
GitHub is shifting from Copilot-only AI to AI embedded across the platform, with AppSec autofix and triage as a major investment area.