에이펌(Affirm), 1주일 만에 AI 에이전트 개발 조직 개편

How Affirm Retooled its Engineering Organization for Agentic Software Development in One Week Affirm Technology 9 min read · Just now -- Listen Share Author: Daniel Martin , Sr. Director of Engineering, Developer Productivity In February 2026, we paused normal engineering delivery for a week and asked over 800 engineers to use agentic AI to take real tasks from ideation through implementation, testing, and code review. We made a deliberate bet that agentic tools had matured enough to change how we work, and that adopting them well would require rethinking the systems around them. This post covers how we got to a place where over 60% of our pull requests (PRs) are agent-assisted: why we did it, how we prepared, what the week looked like, what broke, and what we are investing in now as a result. Why We Did It Affirm has built a credit network that delivers honest financial products at a scale of over 130 million transactions a year. Further scaling of that network depends on our capacity to ship quality software, but we operate under several constraints on our speed. We move money, so mistakes are costly and quality is contractually non-negotiable. We build on a twelve-year-old monorepo with structural bottlenecks: bloated test suites, manual code review, unstable CI, and deploy infrastructure not made for the pace we need. I lead Developer Productivity, the organization that exists to remove those bottlenecks. Throughout 2025, we had already invested in AI-assisted development and, by December, over 80% of our engineering team was a weekly active user in an AI assisted developer tool. But around that time, a new class of tool had crossed a threshold. Models like Anthropic’s Opus 4.5 made agentic AI development practical: coding agents could now reliably search a codebase, plan an approach, write code, run tests, and iterate on failures with minimal human intervention. Our data and interviews showed that a few dozen engineers were already using these tools effectively on our codebase and it was transforming how they worked. The question was how to bring that same acceleration to another 800 developers at Affirm. In mid-January, our President sent a company-wide message: agentic AI development would become a core part of how we build software. The message also set a date for AI Retooling Week. All non-essential meetings would be suspended, product delivery dates delayed, and every engineer and manager asked to complete a fully agentic workflow — from task to submitted PR — by the end of the week. We chose a dedicated week over a gradual rollout because the gap between the engineers already using these tools effectively and their peers was growing and we wanted to close it fast. Building the Foundation In the buildup to Retooling, we assembled a working group of nine engineers. Their mandate: in two weeks produce a repeatable agentic workflow that allows the average developer at Affirm to automate most of their coding work without bespoke setup or expert knowledge. The group made three decisions that shaped everything that followed. First, a single default toolchain. We chose Claude Code as our default agentic coding tool and wrote the entire workflow against its primitives, so engineers had a clear starting point on day one. Second, local-first development, because the tooling landscape had not converged on a centralized platform and we wanted engineers to be productive immediately. Third, explicit human checkpoints where judgment matters: providing intent, approving plans, reviewing code, and merging. Outside those checkpoints, we automated as much toil as we could safely remove. “Default” tooling did not mean “mandatory.” It meant lowered friction to get started. Engineers who preferred other tools could reuse most of the same artifacts with light translation. Where the defaults did not fit, Tech Leads owned the adaptation for their team. The mental model we taught was simple and tool-agnostic: Plan, Review, Execute, Verify, Review, Deliver. The Workflow The workflow we delivered was built around the principle one task equals one agent session equals one PR. A key insight was to move decision-making earlier. Rather than going back and forth with an agent at implementation time, you make the architectural and scoping decisions upfront during planning, then hand the agent a tightly scoped task. This lets engineers work through multiple tasks in parallel on separate worktrees, each a self-contained unit of work. We built custom tooling for each stage of the loop: Plan — an agent-assisted planning skill transforms requirements into a structured implementation plan and breaks it into well-scoped tasks. Review — the engineer reviews and approves the plan before any code is written. Execute — the agent implements a single task on a dedicated worktree. Verify — the agent runs tests and linters, fixes what it finds, and reviews its own code. When CI fails, it fetches build logs, correlates failures, and proposes fixes. This loop repeats until CI passes. Review — the engineer reviews and edits the agent’s output. One rule we were explicit about: do not send unreviewed AI output to your coworkers. Reviewers use agents too, pointing the review tool at the PR along with their team’s architectural context. But the reviewer reads the code, applies their own judgment, and catches what the agent misses. Deliver — the engineer receives human approval and merges. Underlying all of this was a system of context files maintained at multiple levels of the codebase: conventions, domain knowledge, and team decisions where agents could find them. We distributed the tooling through an internal plugin with a central marketplace where teams could build and share their own skills. Retooling Week The week was structured to balance learning with doing. Monday opened with a leadership kickoff and a live demo of the full workflow on a real task. Tuesday featured “art of the possible” sessions held in-person and remotely, where engineers saw the tools tested on real-world tasks. Wednesday was heads-down time. Thursday was team-led demos. Friday was the big show: org-wide demos of the best work from the week, selected by engineering leaders and voted on by the whole organization. Throughout the week we staffed dedicated support channels by timezone, ran helpdesk sessions for anyone who was stuck, and tracked a leaderboard of agentic PR submissions by team. We acknowledged that progress would be lumpy, that some codebases and types of tasks would be harder than others, and we asked teams to give each other grace. The emphasis was on experimentation over perfection. What We Found We measured everything. Adoption rate by team and workflow step, PR volume, opened versus merged PR count. We set a budget of nearly $200k (around $250/engineer) for the week’s token usage and monitored spend daily, investigated outlier patterns, and landed at around 70% of budget. By the end of the week, 92% of the engineering organization, including managers, had submitted at least one agentic PR, most many more. We surveyed every team. Engineers who had been unsure about agentic tools were finding them useful by mid-week, and teams were already asking how to keep the momentum going after the week ended. But the most valuable output was a candid picture of what did not work. Several bottlenecks stood out: Our change review process was the single most-cited friction point in the engineering-wide survey we ran, with roughly 40% of respondents raising it unprompted. PRs often sit at this stage for days, and as volume scaled manual review processes became a chokepoint. CI speed and reliability were a major constraint. Our unit test suite at p75 ran in ~8 minutes, but full end to end regression suites on our ephemeral test environments took an excruciating 100+ minutes. It was not designed for the change-validate-fix-revalidate loops that agentic development demands. Tool integrations created unexpected friction.