-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathwhy-it-matters.html
More file actions
431 lines (366 loc) · 29.3 KB
/
why-it-matters.html
File metadata and controls
431 lines (366 loc) · 29.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Why it matters — the team scale problem</title>
<style>
:root{
--bg:#FAF8F3;--surface:#FFFFFF;--text:#2C2C2A;--muted:#5F5E5A;
--subtle:#B4B2A9;--border:rgba(44,44,42,0.10);--link:#185FA5;
--green:#1a7f37;--green-bg:#eaf3de;--green-text:#27500a;
--blue:#0969da;--blue-bg:#e6f1fb;--blue-text:#0c447c;
--amber:#ba7517;--amber-bg:#faeeda;--amber-text:#633806;
--red:#cf222e;--red-bg:#fcebeb;--red-text:#791f1f;
--purple:#7f77dd;--purple-bg:#eeedfe;--purple-text:#3c3489;
}
@media(prefers-color-scheme:dark){
:root{--bg:#1A1A18;--surface:#242422;--text:#E8E6DE;--muted:#B4B2A9;
--subtle:#5F5E5A;--border:rgba(255,255,255,0.08);--link:#85B7EB;
--green:#3fb950;--green-bg:#04342C;--green-text:#9FE1CB;
--blue:#79c0ff;--blue-bg:#042C53;--blue-text:#85B7EB;
--amber:#d29922;--amber-bg:#412402;--amber-text:#FAC775;
--red:#f85149;--red-bg:#501313;--red-text:#F09595;
--purple:#a5a0f0;--purple-bg:#26215C;--purple-text:#AFA9EC;
}
}
*{box-sizing:border-box;margin:0;padding:0;}
body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",system-ui,sans-serif;
font-size:16px;background:var(--bg);color:var(--text);line-height:1.75;}
.page{max-width:700px;margin:0 auto;padding:56px 24px 80px;}
h1{font-size:32px;font-weight:500;letter-spacing:-.02em;line-height:1.25;margin-bottom:8px;}
h2{font-size:22px;font-weight:500;letter-spacing:-.01em;margin:52px 0 14px;}
h3{font-size:17px;font-weight:500;margin-bottom:8px;}
p{color:var(--muted);margin-bottom:14px;}
p strong{color:var(--text);font-weight:500;}
a{color:var(--link);text-decoration:none;}
a:hover{text-decoration:underline;}
.lede{font-size:19px;color:var(--muted);margin-bottom:40px;line-height:1.6;}
hr{border:none;border-top:.5px solid var(--border);margin:48px 0;}
.callout{border-left:3px solid var(--blue);padding:14px 18px;
background:var(--blue-bg);border-radius:0 8px 8px 0;margin:24px 0;}
.callout p{color:var(--blue-text);margin:0;font-size:15px;line-height:1.65;}
.callout strong{color:var(--blue-text);}
.scenario{display:grid;grid-template-columns:1fr 1fr;gap:16px;margin:24px 0;}
@media(max-width:560px){.scenario{grid-template-columns:1fr;}}
.sc{background:var(--surface);border:.5px solid var(--border);border-radius:12px;
padding:18px 20px;}
.sc.good{border-left:3px solid var(--green);}
.sc.bad{border-left:3px solid var(--red);}
.sc h3{font-size:14px;margin-bottom:6px;}
.sc h3.g{color:var(--green);}
.sc h3.r{color:var(--red);}
.sc p{font-size:14px;margin-bottom:0;}
.half-life{margin:24px 0;}
.hl-row{display:flex;align-items:center;gap:10px;margin-bottom:10px;}
.hl-label{font-size:13px;color:var(--muted);width:200px;flex-shrink:0;}
.hl-track{flex:1;height:12px;background:var(--border);border-radius:6px;overflow:hidden;}
.hl-fill{height:100%;border-radius:6px;}
.hl-note{font-size:11px;color:var(--subtle);margin-left:4px;min-width:120px;}
.three-things{counter-reset:things;margin:20px 0;}
.thing{display:flex;gap:14px;margin-bottom:20px;padding-bottom:20px;
border-bottom:.5px solid var(--border);}
.thing:last-child{border-bottom:none;margin-bottom:0;padding-bottom:0;}
.thing-num{font-size:28px;font-weight:500;color:var(--border);flex-shrink:0;
width:36px;text-align:center;line-height:1;padding-top:2px;}
.thing-body h3{font-size:15px;margin-bottom:4px;}
.thing-body p{font-size:14px;margin-bottom:0;}
/* Conversation questions */
.q-list{list-style:none;padding:0;margin:20px 0;}
.q-list li{display:flex;gap:12px;align-items:flex-start;padding:12px 0;
border-bottom:.5px solid var(--border);font-size:14px;color:var(--muted);}
.q-list li:last-child{border-bottom:none;}
.q-bullet{width:20px;height:20px;border-radius:50%;background:var(--green-bg);
color:var(--green-text);font-size:11px;font-weight:600;display:flex;
align-items:center;justify-content:center;flex-shrink:0;margin-top:2px;}
/* Objection handling */
.objections{margin:20px 0;}
.objection{background:var(--surface);border:.5px solid var(--border);
border-radius:12px;padding:18px 20px;margin-bottom:12px;}
.objection-q{font-size:14px;font-weight:500;color:var(--text);margin-bottom:10px;
padding-bottom:10px;border-bottom:.5px solid var(--border);}
.objection-q::before{content:"Objection: ";color:var(--red);font-weight:600;}
.objection-a{font-size:14px;color:var(--muted);line-height:1.65;margin:0;}
.objection-a::before{content:"Response: ";color:var(--green);font-weight:600;
font-size:11px;text-transform:uppercase;letter-spacing:.3px;}
/* Nav cards */
.nav-cards{display:grid;grid-template-columns:1fr 1fr;gap:12px;margin:28px 0;}
@media(max-width:480px){.nav-cards{grid-template-columns:1fr;}}
.nav-card{background:var(--surface);border:.5px solid var(--border);border-radius:12px;
padding:16px 18px;text-decoration:none;display:block;transition:border-color .15s;}
.nav-card:hover{border-color:var(--link);text-decoration:none;}
.nav-card-label{font-size:11px;text-transform:uppercase;letter-spacing:.5px;
color:var(--subtle);margin-bottom:6px;}
.nav-card h3{font-size:14px;color:var(--link);margin-bottom:4px;}
.nav-card p{font-size:13px;margin-bottom:0;}
.win-row{display:grid;grid-template-columns:1fr 1fr;gap:16px;margin:24px 0;}
@media(max-width:560px){.win-row{grid-template-columns:1fr;}}
.win-cell{background:var(--surface);border:.5px solid var(--border);border-radius:10px;padding:16px 18px;}
.win-cell.gh{border-left:3px solid var(--green);}
.win-cell.ext{border-left:3px solid var(--red);}
.win-cell-label{font-size:11px;text-transform:uppercase;letter-spacing:.4px;margin-bottom:8px;}
.win-cell-label.gh{color:var(--green);}
.win-cell-label.ext{color:var(--red);}
.win-cell ul{list-style:none;padding:0;}
.win-cell ul li{font-size:13px;color:var(--muted);padding:4px 0;border-bottom:.5px solid var(--border);}
.win-cell ul li:last-child{border-bottom:none;}
/* Glossary */
.glossary{margin:28px 0;}
.glossary dl{display:grid;row-gap:0;}
.glossary dt{font-size:14px;font-weight:600;color:var(--text);padding:14px 0 4px;
border-top:.5px solid var(--border);}
.glossary dd{font-size:14px;color:var(--muted);margin:0 0 14px 0;line-height:1.65;}
.glossary dd em{color:var(--text);font-style:normal;font-weight:500;}
footer{margin-top:48px;padding-top:20px;border-top:.5px solid var(--border);
font-size:12px;color:var(--subtle);}
</style>
</head>
<body>
<div class="page">
<p style="font-size:13px;color:var(--subtle);margin-bottom:16px">
<a href="/">claynelson.github.io</a> › why it matters
</p>
<h1>Why the best AI tool for one developer breaks at five</h1>
<p class="lede">A plain-language explainer — and field guide — for anyone selling or building with GitHub in the era of AI coding agents.</p>
<hr style="margin-top:0">
<h2>Start with a golf caddie</h2>
<p>Imagine a scratch golfer with an exceptional caddie. The caddie has watched every round. They know the golfer reads uphill putts with a slight pull. They know not to suggest the 7-iron on the 14th when there's any wind from the south. They carry the entire philosophy of that golfer's game in their head.</p>
<p>That golfer, with that caddie, is exceptional. They win rounds they have no business winning — because the caddie isn't just carrying clubs. The caddie is carrying <strong>strategic memory</strong>.</p>
<p>This is what Claude Code does for a solo developer today. It isn't just writing code. It's holding the design philosophy, the sequencing decisions, the reasons why things are structured the way they are — all in a single coherent context. The developer doesn't have to re-explain themselves at every step. The intent travels with the work.</p>
<div class="callout">
<p><strong>The caddie insight:</strong> The value isn't the clubs. It's the continuous memory of intent across the whole round.</p>
</div>
<h2>Now add four more golfers</h2>
<p>Same golf course. Now there are five golfers, each with their own private caddie. The caddies have never spoken to each other. Each one knows their own golfer's game deeply — but has no idea what the other four are doing.</p>
<p>They all tee off at the same time. Two of them choose the same line down the 4th fairway. Three caddies independently decide their golfer should play aggressively toward the same pin. Nobody is wrong about their own golfer — but the course is chaos.</p>
<p>This is a five-developer team where every developer is running an AI agent with no shared context. Each agent is excellent at serving its own developer. Together, they are competing for the same parts of the codebase with no awareness of each other.</p>
<div class="scenario">
<div class="sc good">
<h3 class="g">Solo developer + Claude Code</h3>
<p>One caddie. Knows every decision you've made. Holds your philosophy. Nothing is lost between sessions.</p>
</div>
<div class="sc bad">
<h3 class="r">5 developers, 5 private agents</h3>
<p>Five caddies, none talking. Each excellent alone. Together: 15 agents competing for the same files, no shared memory of why anything was built the way it was.</p>
</div>
</div>
<h2>Three things go wrong</h2>
<div class="three-things">
<div class="thing">
<div class="thing-num">1</div>
<div class="thing-body">
<h3>The coordination edges multiply faster than you expect</h3>
<p>With two developers, there's one <strong>edge</strong> — one connection that needs to be managed — between them. With five, there are ten. But here's the new part: each developer running three AI agents isn't one person anymore — they're a small team. At five developers with three agents each, you have 105 potential conflict edges. Most of those are <strong>invisible</strong>. No agent knows what another is doing. <em>(Not sure what an edge is? See the glossary below.)</em></p>
</div>
</div>
<div class="thing">
<div class="thing-num">2</div>
<div class="thing-body">
<h3>Some files are like the 18th green — everyone ends up there</h3>
<p>In any codebase, a small number of files are touched by almost every feature: configuration files, routing tables, database schema, the app's main entry point. These are <strong>hub files</strong>. When five developers run agents in parallel, each agent working on its own feature will independently try to update these files. A recent benchmark found that Git's merge algorithm creates false conflicts on nearly half of these cases — not because the changes actually conflict, but because Git reads lines of text, not intent.</p>
</div>
</div>
<div class="thing">
<div class="thing-num">3</div>
<div class="thing-body">
<h3>The philosophy disappears when the conversation ends</h3>
<p>When the caddie goes home, the strategic memory goes with them. Every Claude Code session, every conversation with an AI agent — when it closes, the reasoning behind the decisions made in that session is gone. At solo scale, the developer is the keeper of that memory. At five-person scale, <strong>no one is</strong>. Two weeks later, nobody can explain why a key architectural decision was made the way it was — because the only record lived in a chat window that closed.</p>
</div>
</div>
</div>
<div class="callout" style="border-left-color:var(--red);background:var(--red-bg)">
<p style="color:var(--red-text)"><strong>The Finishing Problem:</strong> When five agents each complete individual steps at 95% accuracy, a 50-step workflow succeeds roughly 8% of the time — and no single agent reports a failure. The math doesn't care how smart each agent is. It cares whether they share a model of what <em>done</em> looks like. <a href="/finishing-problem.html" style="color:var(--red-text);text-decoration:underline">Run the simulation →</a></p>
</div>
<hr>
<h2>What GitHub provides that a private caddie can’t</h2>
<p>Think about what makes a golf tournament work. It isn't five exceptional caddies. It's the course itself: the tee sheets that sequence who plays when, the scorecards that create a shared record, the rules that every player and caddie operates under. The course is the <strong>coordination infrastructure</strong>.</p>
<p>GitHub is that infrastructure for software development. Pull requests aren't just code review — they're the contract between parallel workstreams. Issues aren't just task tracking — they're durable records of why decisions were made, recoverable months later when a new agent needs to understand the context. The branch rules aren't bureaucracy — they're the tee sheet that prevents two agents from teeing off on the same hole.</p>
<p>When agents live <strong>inside</strong> GitHub, through Copilot, they share this infrastructure natively. When agents live <strong>outside</strong> GitHub, like Claude Code running externally, they are brilliant private caddies operating on a course with no tee sheet, no shared scorecards, and no rules about who plays when.</p>
<div class="callout">
<p><strong>External agents hold snapshots. GitHub holds causality.</strong> Snapshots tell you what the code is. Causality tells you why it became that way — the attributed, timestamped, immutable chain from intent to commit. That's the coordination layer no external agent can replicate, because it lives in the platform, not the conversation.</p>
</div>
<h2>Where this becomes a compliance problem</h2>
<p>In consumer software, the philosophy-disappears problem is a productivity concern. In regulated industries, it's an audit failure.</p>
<div class="callout" style="border-left-color:var(--amber);background:var(--amber-bg)">
<p style="color:var(--amber-text)"><strong>ISO 26262, DO-178C, and IEC 62443</strong> all require demonstrable traceability between intent and implementation. When the reasoning behind a safety-critical decision lives only in a closed chat window, it never existed from a compliance standpoint. Tool qualification in regulated environments doesn't mean qualifying the AI model — it means qualifying the <em>process around</em> the model. GitHub provides that process. External agents don't.</p>
</div>
<p>This is why automotive, aerospace, and industrial teams aren't asking “which agent is smartest?” They're asking “which agent can I put in front of an auditor?” That question requires a system that holds causality — not just one that generates capable output.</p>
<h2>How long does the reasoning survive?</h2>
<p>An architectural decision gets made. How findable is the <em>reasoning behind that decision</em> two months from now?</p>
<div class="half-life">
<div class="hl-row">
<span class="hl-label">External chat session</span>
<div class="hl-track"><div class="hl-fill" style="background:var(--red);width:4%"></div></div>
<span class="hl-note">gone at session end</span>
</div>
<div class="hl-row">
<span class="hl-label">PR description</span>
<div class="hl-track"><div class="hl-fill" style="background:var(--amber);width:36%"></div></div>
<span class="hl-note">fades as codebase grows</span>
</div>
<div class="hl-row">
<span class="hl-label">GitHub Issues + PR link</span>
<div class="hl-track"><div class="hl-fill" style="background:var(--green);width:88%"></div></div>
<span class="hl-note">findable months later</span>
</div>
<div class="hl-row">
<span class="hl-label">GitHub Agentic Workflows</span>
<div class="hl-track"><div class="hl-fill" style="background:var(--blue);width:96%"></div></div>
<span class="hl-note">reasoning tied to commit graph</span>
</div>
</div>
<p style="font-size:12px;color:var(--subtle);margin-top:-8px">GitHub Agentic Workflows, launched February 2026, ties multi-step agent reasoning directly to the GitHub event graph — attributed, searchable, and recoverable without a third-party capture layer.</p>
<p>When five developers run external agents, the team's collective reasoning about the codebase is stored almost entirely in individual chat histories that nobody can search. When they work through GitHub, that reasoning accumulates in Issues and PRs — findable, searchable, and available to the next agent that picks up the work.</p>
<hr>
<h2>Where GitHub wins the agent conversation</h2>
<p>The field question is almost never “is Copilot smarter than Claude Code?” Developers who love Claude Code should — it's exceptional for solo work. Don't argue that point.</p>
<p>The question to raise instead is about coordination. GitHub is the only platform where agents operate <em>inside</em> the development infrastructure rather than alongside it.</p>
<div class="win-row">
<div class="win-cell gh">
<div class="win-cell-label gh">GitHub wins</div>
<ul>
<li>Teams of 5 or more developers</li>
<li>Multiple agents running in parallel</li>
<li>Any workflow requiring shared context</li>
<li>Regulated industries needing audit trails</li>
<li>Long-lived codebases where intent must survive</li>
<li>Customers who've already felt the merge chaos</li>
</ul>
</div>
<div class="win-cell ext">
<div class="win-cell-label ext">Where external agents shine</div>
<ul>
<li>Solo developer, deep focus work</li>
<li>Short-lived, self-contained tasks</li>
<li>Greenfield exploration with no shared state</li>
<li>Tasks where context fits in one conversation</li>
</ul>
</div>
</div>
<div class="three-things" style="margin-top:32px">
<div class="thing">
<div class="thing-num">1</div>
<div class="thing-body">
<h3>Lead with the coordination problem, not the agent comparison</h3>
<p>“Your developers are already using AI agents. The question isn't which one is smarter — it's whether they share a model of the codebase. Right now, most teams have five brilliant caddies who've never spoken. GitHub is the course that makes coordination possible.”</p>
</div>
</div>
<div class="thing">
<div class="thing-num">2</div>
<div class="thing-body">
<h3>Ask about the merge chaos — they've already felt it</h3>
<p>Customers who've run multiple agents in parallel don't need convincing about the problem. They need a name for it. “Have you seen hub file conflicts that didn't make sense? Architectural decisions that got reversed because nobody remembered why they were made?” When you name the pattern, they recognize it immediately.</p>
</div>
</div>
<div class="thing">
<div class="thing-num">3</div>
<div class="thing-body">
<h3>For regulated industries: compliance is the forcing function</h3>
<p>In automotive, aerospace, and industrial accounts, close with the audit question: “Can you show an auditor the reasoning chain from requirement to commit?” External agents can't answer that. GitHub Agentic Workflows — inside the pull request, tied to the issue, linked to the branch — can. That's not a feature comparison. That's a qualification conversation.</p>
</div>
</div>
</div>
<h2>Questions that open the real conversation</h2>
<p>Stop leading with “our agent is better than Claude.” Start here instead — customers who have scaled beyond 3–5 heavy AI users will recognize these problems immediately:</p>
<ul class="q-list">
<li>
<span class="q-bullet">?</span>
<span>“How much merge chaos and rework are you seeing when multiple developers use AI agents in parallel?”</span>
</li>
<li>
<span class="q-bullet">?</span>
<span>“When an agent makes a big architectural decision, how does the rest of the team understand <em>why</em> it was made six weeks later?”</span>
</li>
<li>
<span class="q-bullet">?</span>
<span>“In your regulated environments, how are you capturing the full reasoning chain for auditors — not just the output, but the decision trail?”</span>
</li>
</ul>
<h2>Objection handling</h2>
<div class="objections">
<div class="objection">
<p class="objection-q">“But our agents can already read the whole repo and use git.”</p>
<p class="objection-a">They can read a snapshot, but they don't share memory or intent across developers and sessions. Reading the repo is not the same as holding the causal chain of why it became what it is. That's where coordination breaks — and that's what GitHub provides natively.</p>
</div>
<div class="objection">
<p class="objection-q">“Claude / Cursor is way better at coding than Copilot.”</p>
<p class="objection-a">You're right — for a single developer on a focused task, external agents are often excellent. Don't argue that. The question changes at team scale: how do you make <em>multiple</em> excellent agents work together without creating chaos? That's not an agent quality problem. It's a coordination infrastructure problem.</p>
</div>
<div class="objection">
<p class="objection-q">“We can just orchestrate everything with LangGraph / CrewAI.”</p>
<p class="objection-a">Orchestration helps sequencing, but it still needs a durable source of truth and an audit trail. GitHub provides that natively — every agent action is tied to the commit graph, the PR, the issue. That's especially critical for compliance and for long-lived codebases where intent must outlive any single session.</p>
</div>
<div class="objection">
<p class="objection-q">“This sounds theoretical.”</p>
<p class="objection-a">Ask your customer directly: how many times have they had to untangle conflicting agent changes on the same files? How many architectural decisions got quietly reversed because nobody could find the original reasoning? At three or more heavy AI users, they've felt this. They may just not have had a name for it yet.</p>
</div>
</div>
<hr>
<h2>The one thing to remember</h2>
<p>The best development teams of the next five years won't be the ones with the smartest agents. They'll be the ones whose agents share a memory.</p>
<p>GitHub is the only platform that holds what agents need to share: not just the code, but the <em>why</em> behind it — the attributed, timestamped, immutable causal chain that makes parallel agent work coherent instead of chaotic.</p>
<div class="callout" style="border-left-color:var(--purple);background:var(--purple-bg)">
<p style="color:var(--purple-text)">“Your developers are already using AI agents. I'm not here to take that away. The question is whether those agents have a shared understanding of what the codebase is doing — or whether they're brilliant caddies who've never talked, operating on a course with no rules. GitHub is the course. The PR is the tee sheet. And right now, a lot of teams are about to find out the hard way that the course matters more than the caddie.”</p>
</div>
<hr>
<h2>Glossary</h2>
<p>A few terms that come up in this piece — explained without assuming a software background.</p>
<div class="glossary">
<dl>
<dt>Agent / AI agent</dt>
<dd>A piece of software that uses an AI model to take sequences of actions on its own — writing code, running tests, making decisions — rather than just answering a single question. Think of it as the difference between asking someone a question and hiring them to complete a project. Claude Code and GitHub Copilot are both examples of AI agents.</dd>
<dt>Coordination edge</dt>
<dd>A <em>connection point</em> between two people (or agents) that requires communication or coordination. If you and a colleague are both editing the same document, there is one edge between you to manage. Add a third person, and now there are three edges (A↔B, B↔C, A↔C). The key insight: edges grow much faster than the number of participants. Five people have ten edges; fifteen agents have 105. Each invisible edge is a potential conflict waiting to happen.</dd>
<dt>Hub file</dt>
<dd>A file in a codebase that nearly every new feature has to touch — like a shared configuration file, a database schema, or the app's main entry point. Hub files are bottlenecks: when multiple agents work in parallel, they all converge on the same hub files independently, creating conflicts even when the underlying changes do not actually interfere with each other.</dd>
<dt>Context / shared context</dt>
<dd>The accumulated knowledge an AI holds during a working session — the decisions made, the reasons behind them, the design philosophy of the project. When a chat session closes, that context disappears. <em>Shared context</em> means multiple agents or developers all working from the same understanding, rather than each holding their own private version of the story.</dd>
<dt>Causality (vs. a snapshot)</dt>
<dd>A <em>snapshot</em> tells you what the code looks like right now. <em>Causality</em> tells you the full chain of why it became that way — who made a decision, when, based on what reasoning, in response to which requirement. Git shows you snapshots. GitHub — through issues, pull requests, and linked agent workflows — preserves causality. For regulated industries, causality is what an auditor actually needs.</dd>
<dt>Merge conflict</dt>
<dd>What happens when two people (or agents) make changes to the same part of a file and the system cannot automatically figure out which version to keep. Git, the underlying version control system, resolves conflicts by comparing lines of text — it has no understanding of <em>intent</em>. This means it often flags conflicts that are not real problems, and occasionally misses conflicts that are.</dd>
<dt>Pull request (PR)</dt>
<dd>A formal proposal to add a set of changes to a shared codebase. In this context, pull requests matter not just as a code review mechanism, but as a durable record: the discussion, the linked issue, the reasoning — all of it lives on the pull request and remains searchable long after the work is done.</dd>
<dt>The Finishing Problem</dt>
<dd>A mathematical observation about compound error rates in multi-step agent workflows. If each step in a 50-step process succeeds 95% of the time — which sounds excellent — the probability that all 50 steps succeed is roughly 8%. No single agent fails catastrophically; the system just quietly does not finish. The problem gets worse as teams run more agents in parallel with no shared model of what “done” means. <a href="/finishing-problem.html">Run the simulation →</a></dd>
<dt>Tool qualification</dt>
<dd>A requirement in regulated industries (automotive, aerospace, medical devices) that any software tool used in a safety-critical development process must be proven to behave predictably and traceably. The key insight for AI: you do not qualify the AI model itself — you qualify the <em>process around it</em>. That process requires documented, auditable workflows, which is exactly what GitHub provides and external chat-based agents do not.</dd>
<dt>GitHub Agentic Workflows</dt>
<dd>A capability launched in February 2026 that allows multi-step agent tasks to run inside GitHub — triggered by issues, pull requests, or other events — with the agent's reasoning and actions tied directly to the GitHub event graph. Unlike external agents that operate in isolated chat sessions, Agentic Workflows leave an attributed, searchable trail of what the agent did and why.</dd>
</dl>
</div>
<hr>
<h2>Ready to go deeper?</h2>
<p style="color:var(--muted);margin-bottom:20px">The pages below show the actual math and let you run simulations. Useful if you want to demonstrate the problem live in a conversation — the sprint conflict simulation in particular makes the abstract very concrete in about 30 seconds.</p>
<div class="nav-cards">
<a class="nav-card" href="/finishing-problem.html">
<div class="nav-card-label">Interactive model</div>
<h3>The Finishing Problem</h3>
<p>See how 95% accuracy per step compounds to 8% workflow success at 50 steps. Drag the sliders to break the math in real time.</p>
</a>
<a class="nav-card" href="/team-scale-math.html">
<div class="nav-card-label">Interactive model</div>
<h3>The team scale math</h3>
<p>Drag a slider from 1 to 5 developers and watch the unmanaged conflict edges multiply. Run a sprint simulation to see hub files light up red.</p>
</a>
</div>
<div class="nav-cards">
<a class="nav-card" href="/token-cost-economics.html">
<div class="nav-card-label">Interactive model</div>
<h3>Token cost economics</h3>
<p>Why early human intervention in an agent workflow is worth 10x more than the same correction made later. The compound cost argument for keeping humans in the loop.</p>
</a>
<a class="nav-card" href="https://github.com/ClayNelson/agent-patterns" target="_blank">
<div class="nav-card-label">Research repository</div>
<h3>Agent patterns — ClayNelson/agent-patterns</h3>
<p>The source research behind this page: framework docs, experimental cases, and a watchlist of startups building into this space.</p>
</a>
</div>
<footer>
Built by <a href="https://github.com/claynelson">Clay Nelson</a> ·
Part of the <a href="https://github.com/ClayNelson/agent-patterns">agent-patterns</a> research project ·
<a href="/">Back to index</a>
</footer>
</div>
</body>
</html>