The 7 phases of AI-driven development — Transcript

Full transcript

1. 0:00What's up friends? I'm going to keep
2. 0:00this short and sweet. I have identified
3. 0:03seven phases of development with AI. In
4. 0:06other words, as you're working through
5. 0:08coding with your AI coding assistant, in
6. 0:10my case Claude Code usually, then these
7. 0:12are the seven phases you should be
8. 0:14thinking about for shipping great work.
9. 0:15The way you achieve these phases is kind
10. 0:17of up to you. There are many different
11. 0:19implementations of it, but these are the
12. 0:21ones that I have kind of understood to
13. 0:24be kind of common across lots and lots
14. 0:26of different approaches. Whether you're
15. 0:28doing rough loops like I mostly am,
16. 0:30whether you're doing GSD, whether you're
17. 0:31using Spec Kit, you are probably going
18. 0:33to be using these seven phases. If you
19. 0:35dig this stuff and you believe that
20. 0:36engineering fundamentals are really
21. 0:38important in the AI age, then guess
22. 0:40what? So do I. And this is what I cover
23. 0:42and elaborate on in my newsletter. This
24. 0:44is not for vibe coders. We are people
25. 0:46that are serious about AI engineering
26. 0:49and serious about building applications
27. 0:50that are built to last. So if that
28. 0:52sounds like you and you want to improve
29. 0:53your skills, then this is the place. But
30. 0:55without further ado, let's go into the
31. 0:57list. Phase one, we start with the idea.
32. 1:00You have some kind of idea, some reason
33. 1:02that you are invoking this progress,
34. 1:04something that you want the AI to do for
35. 1:07you. This might be that you have an
36. 1:08entire app idea that you want to build.
37. 1:10Or you might just have a narrow thing
38. 1:12that you want to complete within the
39. 1:13code base that you're in, like a bug fix
40. 1:15or a feature. I also count refactors as
41. 1:18part of this, too. So if you have a code
42. 1:19base that you need to refactor, then
43. 1:21this process will work for you, too.
44. 1:22This idea can be as small and as big as
45. 1:25you like. We can expand this idea and
46. 1:27this process can take very very large
47. 1:30ideas and turn them into reality. Or it
48. 1:32can be teeny, very narrow and very
49. 1:33focused. Doesn't matter. Now, just to
50. 1:35give you a glimpse of the future setup
51. 1:36here, the idea is going to be turned
52. 1:39into a set of tickets, which a kind of
53. 1:42AI is going to complete. Now, that set
54. 1:44of tickets might end up being lots and
55. 1:46lots of different kind of like AIs
56. 1:47working at once, or maybe just a big
57. 1:50list of tasks that the AI is going to
58. 1:52complete sequentially. So if this idea
59. 1:53involves any kind of research here, any
60. 1:56kind of like difficult explore phases as
61. 2:00part of building the code, then you may
62. 2:02want to include a research phase now.
63. 2:04For instance, if you're doing like a
64. 2:05Stripe integration or maybe integrating
65. 2:07with an API that's not very common, then
66. 2:10you might want to create an asset that
67. 2:13kind of takes all of the research about
68. 2:15that thing like based on your idea and
69. 2:17kind of caches it and puts it inside the
70. 2:20repo or somewhere that your agent can
71. 2:21access. Essentially, every time your
72. 2:23agent is doing work, it might need to
73. 2:25explore the repo in a fresh context
74. 2:27window. And if that exploration is
75. 2:29difficult, so it's an external API or
76. 2:32it's somewhere that's hard to access,
77. 2:33then you'll want to cache it in a
78. 2:35research.md asset and you'll definitely
79. 2:37want to run a research phase at this
80. 2:39point. The next step after research is
81. 2:41to get to prototyping. Now, in the
82. 2:43prototype stage, we're still not really
83. 2:45sure what we're actually building on
84. 2:48even maybe why we're building it.
85. 2:49Prototyping is really important if you
86. 2:52need to impose your taste on the
87. 2:54outcome. words, maybe you need some UI
88. 2:56that needs to look a certain way or
89. 2:58behave a certain way. You're not quite
90. 2:59sure which one to do. What I tend to do
91. 3:01is just chuck up a bunch of different
92. 3:03ideas on a throwaway route, which is
93. 3:06kind of like the LLM showing me all of
94. 3:07the different ways it can think of to
95. 3:09build out the prototype. I then iterate
96. 3:11on the prototype inside a couple of
97. 3:13sessions and say, "Okay, now that one
98. 3:14looks like the best." I found that doing
99. 3:16this early is absolutely essential
100. 3:18because then you can actually commit the
101. 3:19prototype to your code base and then
102. 3:21make that available to the agent when it
103. 3:23actually goes to implement it. The next
104. 3:25step, we are in step four now is to
105. 3:26create a PRD. Now that we understand a
106. 3:29bit more about the kind of like external
107. 3:31APIs that we're using in the research
108. 3:33phase, now that we understand a bit more
109. 3:35about the prototype and we've actually
110. 3:37seen some code, it's time to start
111. 3:39actually properly describing the
112. 3:41destination. We should now feel
113. 3:42confident in ourselves that we can kind
114. 3:44of like understand the end state, what
115. 3:47we're trying to create at the end. We
116. 3:48won't know all of the implementation
117. 3:50decisions yet. We will just kind of know
118. 3:52the basic stuff that the user is going
119. 3:54to see and the way that it's going to
120. 3:56behave. We don't have to call this a
121. 3:57PRD, by the way. This is a PRD is a
122. 3:59product requirements document, but
123. 4:01really it's just some kind of document
124. 4:03that describes the end state of where
125. 4:04we're going. Now, in the process of
126. 4:05creating this end state, we really need
127. 4:07to hammer out the design. And this means
128. 4:09we need to prompt the agent to
129. 4:11absolutely grill us walking down every
130. 4:14part of our decision tree. I have a
131. 4:16write a PRD skill that is purpose
132. 4:18designed for this, which I will link to
133. 4:20below if you're interested. But once
134. 4:21we've created the PRD, then it's time to
135. 4:24actually start breaking down the PRD
136. 4:26into some kind of implementation plan.
137. 4:28For those of you who are not developers
138. 4:30or you've never used a, I don't know, a
139. 4:31Kanban board or a Jira board or anything
140. 4:33like that, a Kanban board is just a list
141. 4:36of tickets that have blocking
142. 4:38relationships between them. We're
143. 4:39essentially just describing the work
144. 4:41that needs to be done. So, I then have a
145. 4:44separate skill for turning my PRD into
146. 4:47separate issues. We could create a
147. 4:48single sequential plan that turns the uh
148. 4:51PRD into like actual code, but with a
149. 4:54Kanban board you actually get to
150. 4:55parallelize really effectively. And so,
151. 4:57I can just literally go on my Kanban
152. 4:59board, find all of the tickets that
153. 5:00aren't blocking, and spin up an agent
154. 5:02for each one and get it to resolve it.
155. 5:05But of course, what I'm starting to talk
156. 5:06about here is execution. So, in some
157. 5:08kind of loop here, run a coding agent to
158. 5:10execute all of the tickets on the Kanban
159. 5:12board. Most times you won't need to
160. 5:14parallelize this. Most times a
161. 5:15sequential agent just working through
162. 5:17each ticket will be enough. And for me,
163. 5:19this is a Ralph loop, which works
164. 5:21really, really effectively with this
165. 5:22setup. And I'll drop some links below on
166. 5:24writing about Ralph that I've done. Now,
167. 5:26finally, once you've done with
168. 5:27execution, you've got a completed asset
169. 5:29for you to actually look at, then you
170. 5:32get the agent to create a QA plan for
171. 5:34the human to QA the completed work. And
172. 5:37what this usually results in is more
173. 5:38tasks in the Kanban board and going
174. 5:40through the execution loop again. So,
175. 5:42you will tend to loop these last three
176. 5:44steps quite a few times until you
177. 5:46iterate towards a perfect product. And
178. 5:48QA here also involves a human actually
179. 5:49going and reading the code that's been
180. 5:51produced during the execution loop. That
181. 5:53might not always be needed, especially
182. 5:55if you're using a kind of gray box
183. 5:56architecture that I've talked about in
184. 5:58previous videos. But overall, these
185. 6:00seven phases are the things I'm thinking
186. 6:02about whenever I'm working with an AI
187. 6:03agent. We start with the idea, some kind
188. 6:06of app or feature or refactor. If we
189. 6:08know there are external dependencies and
190. 6:10difficult to execute explore phases,
191. 6:12then we cache it in a research phase.
192. 6:14And by the way, this research generally
193. 6:16only lives for the lifetime of this
194. 6:18sprint essentially, or the lifetime of
195. 6:20the idea that we're imposing on the app.
196. 6:22The reason for that is that research can
197. 6:24go out of date, or it can just rot away
198. 6:26essentially, and actually cause our
199. 6:28agent to take a wrong turn where it's
200. 6:31not needed. If I need to impose my
201. 6:32taste, then I will use a prototype here.
202. 6:35So, I'll really just sit with an agent,
203. 6:37human in the loop, to hash out some
204. 6:39ideas. This is not just for design as
205. 6:41well. It can be for a software
206. 6:42architecture, too, or let's say testing
207. 6:45something out with an external service.
208. 6:46This is an essential step because by the
209. 6:48time we get to the PRD, it's a little
210. 6:49bit too abstract. You really need
211. 6:51concrete feedback first. Then I write
212. 6:53the PRD, which is the documentation, the
213. 6:56spec for where we are going. Next, I
214. 6:58make a kind of understanding of the
215. 7:00journey towards the PRD by turning it
216. 7:02into a Kanban board. I generally use
217. 7:04GitHub issues for both the PRD and the
218. 7:06Kanban board, by the way. It's just an
219. 7:08easy thing I found. Although GitHub
220. 7:10doesn't have yet a kind of built-in way
221. 7:12to represent blocking relationships
222. 7:14between tickets. So, you might be just
223. 7:16better off with something like Linear,
224. 7:17which does. Once the Kanban board is all
225. 7:19ready and set up, then I execute it in
226. 7:21some kind of loop. For me, that's a
227. 7:23Ralph loop. You could also, I suppose,
228. 7:25do execution human in the loop style,
229. 7:27where you sit and execute the tickets
230. 7:30individually. But I generally find with
231. 7:31all of this setup, with the research,
232. 7:33with the prototype, with the Kanban
233. 7:35board, with the PRD helping it, you can
234. 7:37totally run this execution loop AFK, and
235. 7:39the results will be really good. And to
236. 7:40make sure that they're really good, we
237. 7:41then enter a QA phase where we get the
238. 7:44agent to produce a QA plan. Then a
239. 7:46human, yes, a human, yep, we're here,
240. 7:49actually walks through and QAs the
241. 7:51completed work and then produces more
242. 7:53tickets for the Kanban board, which then
243. 7:55goes and executed, more QA, you get the
244. 7:58idea. So what do you think about this?
245. 7:59What did I get wrong and what am I
246. 8:00missing here? I imagine these phases
247. 8:02will grow to eight phases and nine
248. 8:04phases as I get more ideas. There's no
249. 8:06explicit mention of code review here,
250. 8:08really. I suppose I could do that as
251. 8:10part of the execution flow. I suppose
252. 8:11maybe it comes under QA, but you know,
253. 8:14it's definitely an essential step to
254. 8:16producing good code. By the way, you can
255. 8:18tell that I care about good code and if
256. 8:19you do too, then you should check out my
257. 8:21newsletter. But whether you sign up or
258. 8:22don't, thanks for watching and I'll see
259. 8:24you very soon.