What is the Future of IDEs — Transcript

Full transcript

1. 0:00Okay, so here's a question that I keep
2. 0:02hearing and honestly, one that I've been
3. 0:04kind of asking myself a lot lately. With
4. 0:07the state of coding agents, the way that
5. 0:09they are, what is the role of IDEs? And
6. 0:13I think it's really easy to be
7. 0:14dismissive and say that you don't need
8. 0:16them at all, but also when I find myself
9. 0:18actually running code that I want to put
10. 0:20into production, that I want to know is
11. 0:22safe and stuff like that, I do want an
12. 0:24IDE that I can actually go and look at
13. 0:27the code and do a variety of different
14. 0:29tasks, etc. So you hand code or codex a
15. 0:32task, it goes off and does a bunch of
16. 0:34changes and usually those changes are
17. 0:36not just changing one file. That could
18. 0:38be touching 10 15 different files there.
19. 0:41And from the terminal alone, you really
20. 0:44can't see any of that. Now that can be
21. 0:46kind of good when you're just trying to
22. 0:48run something on your phone, you're
23. 0:50trying to get an idea down, you're
24. 0:51trying to do something like that. But I
25. 0:53still believe if you're going to call
26. 0:54yourself a developer, that you need to
27. 0:56know what the code is actually doing.
28. 0:59You need to know that the code is still
29. 1:01right. And in some way, shape or form, I
30. 1:03feel you can't leave all of that to AI.
31. 1:05So this video is sponsored by Jet
32. 1:07Brains. It's not a big push though for
33. 1:09any particular product that they make or
34. 1:11anything. It came about from me talking
35. 1:13to them and then publishing a blog post.
36. 1:15And that whole idea of that is really
37. 1:18what do you need an IDE for in this day
38. 1:20and age? And I got my own answer to this
39. 1:23and it's really no longer about writing
40. 1:25code at all here. Okay, so just to set a
41. 1:27bit of background here, when Jet Brains
42. 1:29reached out about this, I wrote back
43. 1:31with my honest take. I said that I think
44. 1:33IDEs still matter, but I think they
45. 1:36drastically need to change. And to be
46. 1:38fair, Jet Brains seems to see it the
47. 1:40same way. Here is their take on what an
48. 1:42IDE looks like when agents are doing a
49. 1:45lot of the writing. And I gave them a
50. 1:47few reasons that I'm going to go through
51. 1:48here. I also want to say on a personal
52. 1:50note that I actually started using Jet
53. 1:53Brains IDEs for doing Objective C
54. 1:55development back in 2012. So I've seen
55. 1:58their products change over years. I
56. 2:00myself never used IntelliJ Idea, but I
57. 2:02had lots of friends who did Java
58. 2:04development who were using IntelliJ
59. 2:06Idea. I used their Python idea at one
60. 2:08stage for doing Django development. And
61. 2:10on the whole, I found them to be a very
62. 2:12thoughtful company in trying to make
63. 2:14products that are really geared for
64. 2:16developers. And honestly, that's why I
65. 2:18accepted the sponsorship here. So going
66. 2:20back and forth with them about IDEs, and
67. 2:22there are a number of things that I told
68. 2:24them that I still think the IDEs are
69. 2:25really important here. One was diffs and
70. 2:29being able to actually see what an agent
71. 2:32has changed. So I see so many people
72. 2:35doing vibe coding where they're just
73. 2:37putting in a prompt, they don't care.
74. 2:39And there's a time and a place for that.
75. 2:41Don't get me wrong. I think that's
76. 2:42really good when you're developing quick
77. 2:44ideas and stuff like that. But for
78. 2:46example, a lot of you have asked me
79. 2:48about the testing suite that I use for
80. 2:50basically testing all of the models. And
81. 2:53that's now become quite an extensive
82. 2:55piece of software there. And in the
83. 2:56process of developing that, I used an
84. 2:58early version of Fable. I used Claude
85. 3:01Code. I used Codex. There are quite a
86. 3:04number of different agents that have
87. 3:06touched that codebase. And often each of
88. 3:08them has got their own idea about how
89. 3:10that should actually all work. So one of
90. 3:13the things that was really important to
91. 3:14me there is not just the low-level code
92. 3:17of how things are actually going. And
93. 3:19that software, for example, can support
94. 3:21a whole bunch of different backends.
95. 3:23Everything from the Gemini APIs, Open
96. 3:26Router APIs, to VLM local, to SG Lang
97. 3:30locally, and even things like Llama CPP
98. 3:32and Nvidia Dynamo, etc. And one of the
99. 3:35most important things with a project
100. 3:37like that is how you basically build
101. 3:39something like that in modules. And you
102. 3:42really need to know how the codebase is
103. 3:44laid out. And this is where I think IDEs
104. 3:47are going to become a lot more important
105. 3:48in the future. That we're very rarely
106. 3:51ever going to use an IDE for handwriting
107. 3:53code. Occasionally, yes, you might go in
108. 3:56and make some changes or do things like
109. 3:58that. But the majority of the time, it's
110. 4:00for inspecting the code and then for
111. 4:03inspecting how that code was made. So
112. 4:06one of the tricks that I learned from
113. 4:07one of the people in Anthropic was to
114. 4:10basically get the agents to create HTML
115. 4:13documentation and HTML diagrams for how
116. 4:16everything is laid out. And that is
117. 4:18really useful and I always try to make
118. 4:20sure that's in a lot of my code bases
119. 4:22when it's something important and I'll
120. 4:24make sure that that actually refers to
121. 4:27file names that I can then go and
122. 4:29actually look at that in an IDE. That's
123. 4:32something that's really crucial here.
124. 4:34Another thing that I think is the IDEs
125. 4:36are kind of merging away from just being
126. 4:39things where you look at code but things
127. 4:41where you run agents. So I think GitHub
128. 4:44Copilot was one of the first ones that
129. 4:45did this and I used them for a time and
130. 4:48they basically had an agent panel as
131. 4:50well as the code panels etc in there.
132. 4:53And for me that started off well but I
133. 4:55honestly moved away from them for a
134. 4:56variety of different reasons. And over
135. 4:59the last six months I've experimented
136. 5:00with a whole bunch of tools. Like you've
137. 5:02probably seen in my videos a couple of
138. 5:03months back that I was using C Mux a lot
139. 5:06and running multiple agents in that and
140. 5:09having that open and then often having
141. 5:11some IDE to actually look at the actual
142. 5:14code as well. I've also experimented
143. 5:16with things like Herda and even more
144. 5:18recently with T 3 code. And even Jet
145. 5:21Brains Air also has these abilities in
146. 5:24it where you can run multiple agents and
147. 5:26then orchestrate them from the IDE
148. 5:29directly. And you're not just limited to
149. 5:31one agent. You can run a whole bunch of
150. 5:33different ones in here. Each of these
151. 5:35solve the problem. I think one of the
152. 5:36key things here is that you want
153. 5:39something that's going to allow you to
154. 5:41be able to go very quickly from the high
155. 5:44level chunks down to the low level
156. 5:47chunks here. Now for a company like Jet
157. 5:49Brains for most of their history IDEs
158. 5:51really were the place where you write
159. 5:53code, right? Gradually later on you had
160. 5:56things like auto complete, you had the
161. 5:58ability to do refactoring. For those of
162. 6:01you who remember actually writing a lot
163. 6:03of code the whole idea of snippets was
164. 6:05really cool, and everyone would have
165. 6:07their own version of personalized,
166. 6:09curated snippets that they used in
167. 6:11developing. And all of that was about
168. 6:12making typing code faster. The early AI
169. 6:16autocompletes were really cool in that
170. 6:18suddenly you didn't need to write a full
171. 6:21function. You could just start off
172. 6:22writing the function, and it would just
173. 6:24autocomplete it and be able to match the
174. 6:26variables and do things like that. Now,
175. 6:28obviously we've come a huge way since
176. 6:31then, and agents have come along. And I
177. 6:33would say not only has that made typing
178. 6:35code, you know, longer the main thing,
179. 6:37more often than not it's actually made
180. 6:39it the bad option. So for sure, if IDEs
181. 6:42[clears throat] were only about typing
182. 6:43code, then they would be in trouble. But
183. 6:45I think a lot of what a really good IDE
184. 6:47does is it helps you read code, helps
185. 6:50you navigate it, helps you understand
186. 6:52it, helps you check it. So if we talk
187. 6:54about where the bottleneck has moved, if
188. 6:56you've been using coding agents
189. 6:58seriously, you've probably noticed this
190. 6:59yourself, right? That an agent can
191. 7:01produce a change in a few minutes, but
192. 7:04then reviewing that change can take you
193. 7:06much longer than it actually writing the
194. 7:09change. This is especially true if
195. 7:11you're the one responsible for
196. 7:13committing that to the codebase for
197. 7:15production. I know for example, in a lot
198. 7:17of organizations like Google, and if you
199. 7:20go back to the interview I did with
200. 7:21Logan Kilpatrick earlier in the year, he
201. 7:22actually talked about this, that
202. 7:24nowadays anyone can write code and
203. 7:27submit a pull request in there. But one
204. 7:30of the software engineers on that
205. 7:32project has to go through it and sign
206. 7:35off on it. And they're the ones that are
207. 7:37responsible for it, not the person who
208. 7:39came up with the idea and vibe coded it
209. 7:42with an agent, etc. So that radically
210. 7:44flips your tools from being just about
211. 7:46generation to much more about curation
212. 7:49now. So JetBrains put out a post
213. 7:51recently based on talking to a bunch of
214. 7:53engineering teams, and the pattern that
215. 7:55they found is pretty much what I see.
216. 7:58Implementation has become quick. The
217. 8:00bottleneck has moved to the code review
218. 8:03and the planning. They talked about that
219. 8:05one team actually measured it and found
220. 8:07that their PR time went up, not down, as
221. 8:10they're actually rolling out agents. And
222. 8:12I think at big organizations, there
223. 8:14really is a trust problem over the
224. 8:17agents of how much can you actually
225. 8:18trust them to do stuff. And honestly, I
226. 8:21kind of feel that that's the right
227. 8:22behavior. I'd be more worried about a
228. 8:24team where review time has gone down to
229. 8:27zero here. And of course, there's a
230. 8:29version of this where people say, well,
231. 8:31just get another agent to do the review
232. 8:33and look, the AI can review itself. It
233. 8:35catches stuff. But that still doesn't
234. 8:38remove the need for a person who
235. 8:40understands what the system is supposed
236. 8:42to do to actually check, not only is it
237. 8:45getting to a good result, is it getting
238. 8:47there in a way that is not breaking the
239. 8:50law, that is not running up huge compute
240. 8:52bills or database bills? And while it's
241. 8:55definitely possible that we may get
242. 8:56there in the future as the models keep
243. 8:58getting better and better, I think at
244. 9:00the present, we still need humans to
245. 9:03actually sign off on what goes into
246. 9:05production. Okay, so let me get concrete
247. 9:07about what actually I use IDEs for
248. 9:10nowadays. So the first off is diffs.
249. 9:12It's the most basic one and probably
250. 9:14still often the most important. But
251. 9:17before anything an agent writes that
252. 9:19gets fully merged, I want at least have
253. 9:22a good sense of
254. 9:24what the file structure is, what's in
255. 9:27those files, has the documentation
256. 9:29actually documented properly what it's
257. 9:31doing? All of those things are sort of
258. 9:34key. And you just can't do that with
259. 9:36with a wall of text in a terminal or
260. 9:38some kind of agent panel where you never
261. 9:40actually see what's going on in the
262. 9:42background.
263. 9:43The second up is navigation. So when the
264. 9:46agent actually changes the function, I
265. 9:48want to be able to jump in to where that
266. 9:51function is actually called. I want to
267. 9:53find usages, see what implements the
268. 9:55interface there. And IDEs have had this
269. 9:58forever, but it's often exactly what you
270. 10:00need to judge whether a change is safe.
271. 10:03And of course, I'll admit that if it's
272. 10:04something that's not that important, I'm
273. 10:06not going to spend that much time on it.
274. 10:08But if it's something that I know is
275. 10:10making uh large amount of database calls
276. 10:13or something like that, I want to check
277. 10:15and see is that done in a reasonably
278. 10:18efficient manner in there. And that kind
279. 10:20of brings me to the third use. And the
280. 10:21third use is verification. So this is
281. 10:24running tests, running the inspections.
282. 10:26And then when something looks off, and
283. 10:28that's not going to be a huge amount of
284. 10:30times, but I want to be able to step
285. 10:32through it with a debugger to actually
286. 10:34see, okay, what is going on here? Or I
287. 10:38want to be able to have a set of tests
288. 10:41that I can run and I can see the outputs
289. 10:44of that in the IDE to see, okay, which
290. 10:47of these tests are running, which of
291. 10:49these tests are failing, which of these
292. 10:51tests are doing well, etc. That's
293. 10:53something that's really key here for any
294. 10:54sort of verification is to be able to
295. 10:57have tests, to be able to quickly look
296. 10:59at those tests and make sure they don't
297. 11:02just have a return equals true on them,
298. 11:05but they're actually doing what you
299. 11:06think they're doing. And then being able
300. 11:08to see the outputs of those and go
301. 11:10through those quickly in a nice way. The
302. 11:12fourth element here, I think is really
303. 11:14underrated, is documentation. I think
304. 11:16that the IDE becomes much of the place
305. 11:19where you document code as it's being
306. 11:21written. So if agents are producing most
307. 11:24of the code, definitely they should be
308. 11:25writing documentation as well, but you
309. 11:28should be reviewing that documentation.
310. 11:30You should be reviewing that what it's
311. 11:33saying it's doing is actually what you
312. 11:35want it to be doing. Just checking
313. 11:37things like why does this particular
314. 11:39component exist? What are the
315. 11:40constraints are here? And then also
316. 11:43being able to see if I asked for one
317. 11:45particular change, did the agent go off
318. 11:47and change things that I didn't want
319. 11:49changed in there? And then having that
320. 11:51allows you to basically feed back into
321. 11:54agents. So that gives you better
322. 11:56documents, that gives you better
323. 11:58context, that gives you better output.
324. 12:00Especially that's true if you're using
325. 12:02multiple agents. So if you're using
326. 12:04something like Claude Code plus Codex
327. 12:06plus Open Code plus a custom harness
328. 12:09that you've created yourself plus a a of
329. 12:10different open models. And I think
330. 12:12that's one of the areas that really gets
331. 12:14overlooked here is that all of this IDE
332. 12:17intelligence isn' just for you. It's
333. 12:19useful for the agent too. An agent that
334. 12:22can only grep through files and have to
335. 12:25basically use its full context window to
336. 12:28sort out what is actually going on is
337. 12:31often an agent that's kind of working
338. 12:32blind. An agent that can kind of work
339. 12:34with what you've given it and what
340. 12:36you're looking at in the IDE and that
341. 12:39can use that IDE to do things like
342. 12:41semantic search across the codebase is
343. 12:44just going to have much better context
344. 12:47and therefore it's just going to be more
345. 12:48accurate. And then on top of that, this
346. 12:50is often just going to save you money by
347. 12:53using fewer tokens. And that's something
348. 12:55I think that we're all being spoilt with
349. 12:58here is that we're paying these $100,
350. 13:00$200 plans, perhaps even going up to
351. 13:03$500 plans now, and you're getting a
352. 13:05very high amount of token usage. If
353. 13:08suddenly that starts to come to a stop
354. 13:10as the models get bigger and better and
355. 13:13you have to start paying for API calls,
356. 13:15this whole game is going to radically
357. 13:17change then. Anyway, hopefully this
358. 13:19video, whatever tools you use, has got
359. 13:21you to think a little bit about the way
360. 13:23that you and your team are actually
361. 13:25building software these days. Like I
362. 13:27said earlier, my whole answer here is
363. 13:29that the IDEs are really not where you
364. 13:32write code anymore. It's where you read
365. 13:34it, where you check it, where you decide
366. 13:36whether it ships. The writing part has
367. 13:38gotten cheap. The verification hasn't.
368. 13:41That's really the direction JetBrains is
369. 13:43heading with AI, bringing the agents
370. 13:45that you already use into the IDE so
371. 13:48that you can review and check their
372. 13:49work. So anyway, I'll include the link
373. 13:51to the blog post on JetBrains IDEs in
374. 13:53the description. You should also check
375. 13:55out AI for yourself. And really I would
376. 13:57like to start a conversation here of
377. 13:59what do you find yourself using to
378. 14:01actually push software into production
379. 14:03here? Now I know some of you are brand
380. 14:05new to software development, but I also
381. 14:07know a lot of people listening to my
382. 14:08channel do this as a full-time job. So
383. 14:11let me know what are the challenges that
384. 14:12you're facing and how are you actually
385. 14:15trying to address and fix those
386. 14:17challenges now that the entire world is
387. 14:20moving to these coding agents as we go
388. 14:22forward? Anyway, as always, if you found
389. 14:24the video useful, please click like and
390. 14:26subscribe, and I will talk to you in the
391. 14:28next video. Bye for now.