Get the best articles from Think Different

Tag: software-engineering

More posts tagged software-engineering

  1. Agentic coding: Planning outputs as the real product of the first turn
  2. MCP servers: Testing MCP servers with a plain JSON-RPC client first
  3. AI coding workflows: Pair-with-AI rituals that survive a team of ten
  4. Prompt engineering for code: Difference between role prompts and persona cosplay
  5. Cline and Roo Code: Routing cheap models for boilerplate, frontier models for design
  6. JetBrains AI Assistant: Scoping Junie tasks by module to keep review tractable
  7. Windsurf: Using write-mode sparingly to protect your muscle memory
  8. Cursor: Pairing tab with explicit intent comments to steer predictions
  9. Google Gemini: Auditing IAM policies with a million-token sweep over Terraform
  10. ChatGPT Codex: Parallelising bug-fix attempts and picking the cleanest patch
  11. Claude Code: Checkpointing long sessions to protect yourself from context rot
  12. GitHub Copilot: Switching models mid-conversation when reasoning quality starts to degrade
  13. Local LLMs with Ollama: Pairing Ollama with Continue or Cline for a private IDE
  14. Agentic coding: What to log when an agent writes for you
  15. MCP servers: Treating MCP servers as a supply chain, not a side project
  16. AI coding workflows: Daily shutdown routine that actually ships code
  17. Prompt engineering for code: Turning specs into prompts without losing the nuance
  18. Cline and Roo Code: Plan mode as a cheap dry run before committing budget
  19. JetBrains AI Assistant: Using inspections as invisible rails for the agent
  20. Windsurf: Keeping the editor quiet until you ask for help
  21. Cursor: Composer runs that land a feature in a single reviewable diff
  22. Google Gemini: Using Gemini CLI as glue between Cloud Run and your local repo
  23. ChatGPT Codex: Using AGENTS.md to describe the environment the sandbox must respect
  24. Claude Code: Writing a CLAUDE.md that captures tacit team knowledge
  25. GitHub Copilot: Running Copilot CLI as a scriptable review step inside pre-commit hooks
  26. Local LLMs with Ollama: Keeping a small local model honest with tight prompts
  27. Agentic coding: Difference between an agent and a slow script
  28. MCP servers: Exposing read-only resources before you expose write actions
  29. AI coding workflows: Small reversible steps instead of one heroic prompt
  30. Prompt engineering for code: Acceptance criteria as the only prompt that matters
  31. Cline and Roo Code: Auditing every tool call before it touches a file
  32. JetBrains AI Assistant: Refactorings that remain safe because JetBrains understands types
  33. Windsurf: Flows that preserve intent across a long refactor
  34. Cursor: Agent mode as a disciplined driver, not a replacement for review
  35. Google Gemini: Debugging a production incident from a screenshot and a log bundle
  36. ChatGPT Codex: Scoping tasks tightly enough that the agent can finish in one pass
  37. Claude Code: Using sub-agents for parallel research across a large codebase
  38. GitHub Copilot: Pairing inline completion with a custom instructions file to enforce house style
  39. Local LLMs with Ollama: Picking a local model for the specific task, not for the benchmark
  40. Agentic coding: Budgets as the only feature that stops a bad loop
  41. MCP servers: Smallest MCP server that earns its keep
  42. AI coding workflows: Review cycle that keeps agent output honest
  43. Prompt engineering for code: Shortest prompt that still passes review
  44. Cline and Roo Code: Picking a model per task instead of per editor
  45. JetBrains AI Assistant: Letting Junie drive while the IDE still owns correctness
  46. Windsurf: Cascade as a deliberate planning surface, not an auto-pilot
  47. Cursor: Writing .cursorrules that actually stay short and enforceable
  48. Google Gemini: Feeding an entire service plus its tests into a single prompt
  49. ChatGPT Codex: Letting Codex open the PR while you stay the reviewer of record
  50. Claude Code: Planning mode as a cheap insurance policy against cascading edits
  51. GitHub Copilot: Using the @workspace agent to plan multi-file refactors before a single line is written
  52. Local LLMs with Ollama: Sunday-afternoon project: your own code reviewer that runs offline
  53. Agentic coding: Building trust with agents the way you build it with juniors
  54. MCP servers: Where the protocol ends and your product begins
  55. AI coding workflows: Resting the agent: when taking the keyboard back beats another turn
  56. Prompt engineering for code: When to stop prompting and start coding
  57. Cline and Roo Code: Treating the agent as a shell you can still read
  58. JetBrains AI Assistant: AI that respects your refactoring history instead of fighting it
  59. Windsurf: Turning agent output into atomic, reviewable commits
  60. Cursor: Using MCP inside Cursor to give the agent a real toolbox
  61. Google Gemini: Separating research (AI Studio) from execution (Code Assist) on purpose
  62. ChatGPT Codex: Replaying failed tasks with tighter prompts instead of starting over
  63. Claude Code: Running Claude Code headlessly in CI as a structured reviewer
  64. GitHub Copilot: Wiring MCP servers into Copilot to give it domain-specific tools
  65. Local LLMs with Ollama: Quantisation choices that actually matter for code
  66. Agentic coding: Why short agent loops beat heroic ones
  67. MCP servers: Sandboxing MCP tool calls so one bad prompt cannot ruin a week
  68. AI coding workflows: Time-boxing agent loops before they eat the day
  69. Prompt engineering for code: Prompts as contracts, not wishes
  70. Cline and Roo Code: Memory banks that outlive a single session
  71. JetBrains AI Assistant: Pairing AI Assistant with Code With Me for remote reviews
  72. Windsurf: Indexing strategies for a monorepo with generated code
  73. Cursor: Migrating a legacy module without losing git history or sanity
  74. Google Gemini: Crossing modalities: log, screenshot, code, spec, all in one turn
  75. ChatGPT Codex: Catching silent test skips before they ship to main
  76. Claude Code: Composing slash commands into a bespoke team-specific DSL
  77. GitHub Copilot: Measuring acceptance rate honestly instead of celebrating vanity metrics
  78. Local LLMs with Ollama: RAG over internal docs without handing them to a third party
  79. Agentic coding: Rollback plans for changes you did not watch land
  80. MCP servers: Versioning MCP servers like APIs, not like scripts
  81. AI coding workflows: Rescue patterns when an agent has gone off the rails
  82. Prompt engineering for code: Few-shot examples that teach taste, not just format
  83. Logging every turn so you can learn from the agent, not just use it
  84. The overlooked value of structural search and replace
  85. When to reach for Cascade and when to fall back to pure editing
  86. Keeping tests running in the background while the agent edits
  87. Keeping answers tight with explicit output contracts
  88. Treating Codex as a junior engineer with an infinite patience budget
  89. Diffing agent output against main before you trust a single file
  90. Leaning on Copilot Edits for multi-file, reviewable diffs instead of raw chat
  91. Caching embeddings locally for a private retrieval layer
  92. The honest case for agents that only suggest
  93. Why your wiki should probably be an MCP resource, not a tool
  94. Writing acceptance tests first, agents second
  95. Diffing prompts the way you diff code
  96. Cline and Roo Code: open-source agents teach you more than closed ones
  97. JetBrains AI Assistant: not every green inspection is an agent task
  98. Windsurf: the value of a pause button in an otherwise relentless agent
  99. Cheap wins: the keybindings that turn Cursor back into a proper editor
  100. Google Gemini: Using long context to write migration scripts that respect every edge
  101. ChatGPT Codex: Splitting epics into Codex-sized tasks on purpose
  102. Claude Code: Quiet art of pausing the agent instead of letting it churn
  103. GitHub Copilot: Underrated power of /explain on legacy code no one dares to touch
  104. Local LLMs with Ollama: When a local 7B beats a cloud 70B in latency-sensitive loops
  105. Agentic coding: How to review a PR an agent opened in the middle of the night
  106. MCP servers: Composing agents over a catalogue of shared MCP tools
  107. AI coding workflows: Treating diffs as the primary artefact, chat as exhaust
  108. Prompt engineering for code: How to write a system prompt you can still read in six months
  109. Cline and Roo Code: Roo modes that codify team-specific workflows
  110. JetBrains AI Assistant: Writing specs as Markdown that Junie can consume
  111. Windsurf: Pairing Cascade with a linter that refuses bad taste
  112. Cursor: Right amount of automation before it becomes magical thinking
  113. Google Gemini: Generating Mermaid architecture diagrams the agent can then critique
  114. ChatGPT Codex: Auditing the diff, not the narrative – the code is the contract
  115. Claude Code: Keeping Claude honest with explicit acceptance criteria, not vibes
  116. GitHub Copilot: Copilot Spaces as shared context libraries for team onboarding
  117. Local LLMs with Ollama: Thermal budget of a MacBook pretending to be a server
  118. Agentic coding: Guardrails before autonomy, always
  119. MCP servers: Least-privilege auth for MCP in a real enterprise
  120. AI coding workflows: Scorecard question: did this PR have to exist?
  121. Prompt engineering for code: Structured outputs: JSON schemas that keep agents honest
  122. Cline and Roo Code: Building an internal guardrails library on top of Cline
  123. JetBrains AI Assistant: When the IDE already knows the answer and the agent just needs to ask
  124. Windsurf: What Windsurf teaches about the ergonomics of agent IDEs
  125. The Quiet Extinction of the Software Engineer as We Knew It
  126. Cursor: Resetting indexes when completions start feeling stale
  127. Google Gemini: Pairing Gemini with Code Assist for refactors that span a whole module
  128. ChatGPT Codex: Keeping the human in the loop by requiring explicit acceptance
  129. Claude Code: Hooks that enforce lint, test and security gates before any write
  130. GitHub Copilot: Constraining the agent with .github/copilot-instructions.md for reproducible behaviour
  131. Local LLMs with Ollama: Running evals locally before trusting a new model
  132. Agentic coding: Planning outputs as the real product of the first turn
  133. MCP servers: Testing MCP servers with a plain JSON-RPC client first
  134. AI coding workflows: Pair-with-AI rituals that survive a team of ten
  135. Prompt engineering for code: Difference between role prompts and persona cosplay
  136. Cline and Roo Code: Routing cheap models for boilerplate, frontier models for design
  137. JetBrains AI Assistant: Scoping Junie tasks by module to keep review tractable
  138. Windsurf: Using write-mode sparingly to protect your muscle memory
  139. Cursor: Pairing tab with explicit intent comments to steer predictions
  140. Monitoring Is More Important Than New Features
  141. Google Gemini: Auditing IAM policies with a million-token sweep over Terraform
  142. ChatGPT Codex: Parallelising bug-fix attempts and picking the cleanest patch
  143. Claude Code: Checkpointing long sessions to protect yourself from context rot
  144. GitHub Copilot: Switching models mid-conversation when reasoning quality starts to degrade
  145. Local LLMs with Ollama: Pairing Ollama with Continue or Cline for a private IDE
  146. Agentic coding: What to log when an agent writes for you
  147. MCP servers: Treating MCP servers as a supply chain, not a side project
  148. AI coding workflows: Daily shutdown routine that actually ships code
  149. Prompt engineering for code: Turning specs into prompts without losing the nuance
  150. Cline and Roo Code: Plan mode as a cheap dry run before committing budget
  151. JetBrains AI Assistant: Using inspections as invisible rails for the agent
  152. Windsurf: Keeping the editor quiet until you ask for help
  153. Cursor: Composer runs that land a feature in a single reviewable diff
  154. Google Gemini: Using Gemini CLI as glue between Cloud Run and your local repo
  155. ChatGPT Codex: Using AGENTS.md to describe the environment the sandbox must respect
  156. Claude Code: Writing a CLAUDE.md that captures tacit team knowledge
  157. GitHub Copilot: Running Copilot CLI as a scriptable review step inside pre-commit hooks
  158. Local LLMs with Ollama: Keeping a small local model honest with tight prompts
  159. Agentic coding: Difference between an agent and a slow script
  160. MCP servers: Exposing read-only resources before you expose write actions
  161. AI coding workflows: Small reversible steps instead of one heroic prompt
  162. Prompt engineering for code: Acceptance criteria as the only prompt that matters
  163. Cline and Roo Code: Auditing every tool call before it touches a file
  164. JetBrains AI Assistant: Refactorings that remain safe because JetBrains understands types
  165. Windsurf: Flows that preserve intent across a long refactor
  166. Cursor: Agent mode as a disciplined driver, not a replacement for review
  167. Google Gemini: Debugging a production incident from a screenshot and a log bundle
  168. ChatGPT Codex: Scoping tasks tightly enough that the agent can finish in one pass
  169. Claude Code: Using sub-agents for parallel research across a large codebase
  170. GitHub Copilot: Pairing inline completion with a custom instructions file to enforce house style
  171. Local LLMs with Ollama: Picking a local model for the specific task, not for the benchmark
  172. Agentic coding: Budgets as the only feature that stops a bad loop
  173. MCP servers: Smallest MCP server that earns its keep
  174. AI coding workflows: Review cycle that keeps agent output honest
  175. Prompt engineering for code: Shortest prompt that still passes review
  176. Cline and Roo Code: Picking a model per task instead of per editor
  177. JetBrains AI Assistant: Letting Junie drive while the IDE still owns correctness
  178. Windsurf: Cascade as a deliberate planning surface, not an auto-pilot
  179. Cursor: Writing .cursorrules that actually stay short and enforceable
  180. Google Gemini: Feeding an entire service plus its tests into a single prompt
  181. ChatGPT Codex: Letting Codex open the PR while you stay the reviewer of record
  182. Claude Code: Planning mode as a cheap insurance policy against cascading edits
  183. GitHub Copilot: Using the @workspace agent to plan multi-file refactors before a single line is written
  184. Local LLMs with Ollama: Sunday-afternoon project: your own code reviewer that runs offline
  185. Agentic coding: Building trust with agents the way you build it with juniors
  186. MCP servers: Where the protocol ends and your product begins
  187. AI coding workflows: Resting the agent: when taking the keyboard back beats another turn
  188. Prompt engineering for code: When to stop prompting and start coding
  189. Cline and Roo Code: Treating the agent as a shell you can still read
  190. JetBrains AI Assistant: AI that respects your refactoring history instead of fighting it
  191. Windsurf: Turning agent output into atomic, reviewable commits
  192. Cursor: Using MCP inside Cursor to give the agent a real toolbox
  193. Google Gemini: Separating research (AI Studio) from execution (Code Assist) on purpose
  194. Monthly Retrospective: What April Taught Me About Technology and Productivity
  195. ChatGPT Codex: Replaying failed tasks with tighter prompts instead of starting over
  196. Why Process Matters More Than Technology
  197. Claude Code: Running Claude Code headlessly in CI as a structured reviewer
  198. GitHub Copilot: Wiring MCP servers into Copilot to give it domain-specific tools
  199. What Being a 10x Developer Actually Means
  200. Local LLMs with Ollama: Quantisation choices that actually matter for code
  201. Agentic coding: Why short agent loops beat heroic ones
  202. MCP servers: Sandboxing MCP tool calls so one bad prompt cannot ruin a week
  203. AI coding workflows: Time-boxing agent loops before they eat the day
  204. Prompt engineering for code: Prompts as contracts, not wishes
  205. Cline and Roo Code: Memory banks that outlive a single session
  206. JetBrains AI Assistant: Pairing AI Assistant with Code With Me for remote reviews
  207. What I Learned from the Worst Production Bugs
  208. Windsurf: Indexing strategies for a monorepo with generated code
  209. Cursor: Migrating a legacy module without losing git history or sanity
  210. Google Gemini: Crossing modalities: log, screenshot, code, spec, all in one turn
  211. Why Monitoring Is More Important Than Feature Development
  212. ChatGPT Codex: Catching silent test skips before they ship to main
  213. Claude Code: Composing slash commands into a bespoke team-specific DSL
  214. GitHub Copilot: Measuring acceptance rate honestly instead of celebrating vanity metrics
  215. Local LLMs with Ollama: RAG over internal docs without handing them to a third party
  216. Why Documentation Matters More Than Perfect Code
  217. Agentic coding: Rollback plans for changes you did not watch land
  218. Technical Debt: How It Arises and How to Realistically Pay It Off
  219. MCP servers: Versioning MCP servers like APIs, not like scripts
  220. AI coding workflows: Rescue patterns when an agent has gone off the rails
  221. Prompt engineering for code: Few-shot examples that teach taste, not just format
  222. Cline and Roo Code: Logging every turn so you can learn from the agent, not just use it
  223. JetBrains AI Assistant: Overlooked value of structural search and replace
  224. Code Review as a Superpower – Not a Necessary Evil
  225. Windsurf: When to reach for Cascade and when to fall back to pure editing
  226. Cursor: Keeping tests running in the background while the agent edits
  227. Google Gemini: Keeping answers tight with explicit output contracts
  228. Why Copy-Paste Is the Biggest Enemy of Sustainable Code
  229. ChatGPT Codex: Treating Codex as a junior engineer with an infinite patience budget
  230. Claude Code: Diffing agent output against main before you trust a single file
  231. GitHub Copilot: Leaning on Copilot Edits for multi-file, reviewable diffs instead of raw chat
  232. Local LLMs with Ollama: Caching embeddings locally for a private retrieval layer
  233. Agentic coding: Honest case for agents that only suggest
  234. MCP servers: Why your wiki should probably be an MCP resource
  235. AI coding workflows: Writing acceptance tests first, agents second
  236. Prompt engineering for code: Diffing prompts the way you diff code
  237. Cline and Roo Code: Why open-source agents are a better teacher than closed ones
  238. JetBrains AI Assistant: Resisting the urge to turn every green inspection into an agent task
  239. Windsurf: Value of a pause button in an otherwise relentless agent
  240. Cursor: Cheap wins: keybindings that turn Cursor into a proper editor
  241. Google Gemini: Using long context to write migration scripts that respect every edge
  242. ChatGPT Codex: Splitting epics into Codex-sized tasks on purpose
  243. Claude Code: Quiet art of pausing the agent instead of letting it churn
  244. GitHub Copilot: Underrated power of /explain on legacy code no one dares to touch
  245. Local LLMs with Ollama: When a local 7B beats a cloud 70B in latency-sensitive loops
  246. Agentic coding: How to review a PR an agent opened in the middle of the night
  247. MCP servers: Composing agents over a catalogue of shared MCP tools
  248. AI coding workflows: Treating diffs as the primary artefact, chat as exhaust
  249. Prompt engineering for code: How to write a system prompt you can still read in six months
  250. Cline and Roo Code: Roo modes that codify team-specific workflows
  251. JetBrains AI Assistant: Writing specs as Markdown that Junie can consume
  252. Windsurf: Pairing Cascade with a linter that refuses bad taste
  253. Cursor: Right amount of automation before it becomes magical thinking
  254. Google Gemini: Generating Mermaid architecture diagrams the agent can then critique
  255. ChatGPT Codex: Auditing the diff, not the narrative – the code is the contract
  256. Claude Code: Keeping Claude honest with explicit acceptance criteria, not vibes
  257. GitHub Copilot: Copilot Spaces as shared context libraries for team onboarding
  258. Local LLMs with Ollama: Thermal budget of a MacBook pretending to be a server
  259. Agentic coding: Guardrails before autonomy, always
  260. MCP servers: Least-privilege auth for MCP in a real enterprise
  261. AI coding workflows: Scorecard question: did this PR have to exist?
  262. Prompt engineering for code: Structured outputs: JSON schemas that keep agents honest
  263. Cline and Roo Code: Building an internal guardrails library on top of Cline
  264. JetBrains AI Assistant: When the IDE already knows the answer and the agent just needs to ask
  265. Windsurf: What Windsurf teaches about the ergonomics of agent IDEs
  266. Cursor: Resetting indexes when completions start feeling stale
  267. Google Gemini: Pairing Gemini with Code Assist for refactors that span a whole module
  268. ChatGPT Codex: Keeping the human in the loop by requiring explicit acceptance
  269. Claude Code: Hooks that enforce lint, test and security gates before any write
  270. GitHub Copilot: Constraining the agent with .github/copilot-instructions.md for reproducible behaviour
  271. Local LLMs with Ollama: Running evals locally before trusting a new model
  272. Agentic coding: Planning outputs as the real product of the first turn
  273. MCP servers: Testing MCP servers with a plain JSON-RPC client first
  274. AI coding workflows: Pair-with-AI rituals that survive a team of ten
  275. Prompt engineering for code: Difference between role prompts and persona cosplay
  276. Cline and Roo Code: Routing cheap models for boilerplate, frontier models for design
  277. JetBrains AI Assistant: Scoping Junie tasks by module to keep review tractable
  278. Windsurf: Using write-mode sparingly to protect your muscle memory
  279. Cursor: Pairing tab with explicit intent comments to steer predictions
  280. Google Gemini: Auditing IAM policies with a million-token sweep over Terraform
  281. ChatGPT Codex: Parallelising bug-fix attempts and picking the cleanest patch
  282. Claude Code: Checkpointing long sessions to protect yourself from context rot
  283. GitHub Copilot: Switching models mid-conversation when reasoning quality starts to degrade
  284. Local LLMs with Ollama: Pairing Ollama with Continue or Cline for a private IDE
  285. Agentic coding: What to log when an agent writes for you
  286. MCP servers: Treating MCP servers as a supply chain, not a side project
  287. AI coding workflows: Daily shutdown routine that actually ships code
  288. Prompt engineering for code: Turning specs into prompts without losing the nuance
  289. Cline and Roo Code: Plan mode as a cheap dry run before committing budget
  290. JetBrains AI Assistant: Using inspections as invisible rails for the agent
  291. Windsurf: Keeping the editor quiet until you ask for help
  292. Cursor: Composer runs that land a feature in a single reviewable diff
  293. Google Gemini: Using Gemini CLI as glue between Cloud Run and your local repo
  294. ChatGPT Codex: Using AGENTS.md to describe the environment the sandbox must respect
  295. Claude Code: Writing a CLAUDE.md that captures tacit team knowledge
  296. GitHub Copilot: Running Copilot CLI as a scriptable review step inside pre-commit hooks
  297. Local LLMs with Ollama: Keeping a small local model honest with tight prompts
  298. Agentic coding: Difference between an agent and a slow script
  299. MCP servers: Exposing read-only resources before you expose write actions
  300. AI coding workflows: Small reversible steps instead of one heroic prompt
  301. Prompt engineering for code: Acceptance criteria as the only prompt that matters
  302. Cline and Roo Code: Auditing every tool call before it touches a file
  303. JetBrains AI Assistant: Refactorings that remain safe because JetBrains understands types
  304. Windsurf: Flows that preserve intent across a long refactor
  305. Cursor: Agent mode as a disciplined driver, not a replacement for review
  306. Google Gemini: Debugging a production incident from a screenshot and a log bundle
  307. ChatGPT Codex: Scoping tasks tightly enough that the agent can finish in one pass
  308. Claude Code: Using sub-agents for parallel research across a large codebase
  309. GitHub Copilot: Pairing inline completion with a custom instructions file to enforce house style
  310. Local LLMs with Ollama: Picking a local model for the specific task, not for the benchmark
  311. Agentic coding: Budgets as the only feature that stops a bad loop
  312. MCP servers: Smallest MCP server that earns its keep
  313. AI coding workflows: Review cycle that keeps agent output honest
  314. Prompt engineering for code: Shortest prompt that still passes review
  315. Cline and Roo Code: Picking a model per task instead of per editor
  316. JetBrains AI Assistant: Letting Junie drive while the IDE still owns correctness
  317. Windsurf: Cascade as a deliberate planning surface, not an auto-pilot
  318. Cursor: Writing .cursorrules that actually stay short and enforceable
  319. Google Gemini: Feeding an entire service plus its tests into a single prompt
  320. ChatGPT Codex: Letting Codex open the PR while you stay the reviewer of record
  321. Claude Code: Planning mode as a cheap insurance policy against cascading edits
  322. GitHub Copilot: Using the @workspace agent to plan multi-file refactors before a single line is written
  323. GitHub Copilot: First honest week with GitHub Copilot on a real codebase
  324. Local LLMs with Ollama: Teaching a team to trust a model they own end to end
  325. Agentic coding: What agentic coding taught us about how we really work
  326. MCP servers: First comparison between MCP and home-grown tool plumbing
  327. AI coding workflows: What we retired because an agent finally did it well
  328. Prompt engineering for code: Prompt engineering as writing, not programming
  329. Cline and Roo Code: Teaching juniors by pairing on Cline sessions
  330. JetBrains AI Assistant: Writing specs tight enough for Junie to execute cleanly
  331. Windsurf: Retrospective after our first Windsurf-heavy sprint
  332. Cursor: Teaching Cursor the house style without a wall of prose
  333. Google Gemini: Gemini for Workspace as the quiet engineering multiplier
  334. ChatGPT Codex: Pairing Codex with tight acceptance criteria for the first time
  335. Claude Code: First pass at measuring Claude Code against ordinary coding
  336. GitHub Copilot: Small refactor Copilot did not quite nail, and why it mattered
  337. Local LLMs with Ollama: First honest benchmark between local and cloud models
  338. Agentic coding: Retrospective after our first week of full agentic coding
  339. MCP servers: Testing MCP servers with the same rigor as customer-facing APIs
  340. AI coding workflows: When taking the keyboard back was the real productivity move
  341. Prompt engineering for code: Honest taxonomy of prompts, as discovered in practice
  342. Cline and Roo Code: Plan mode budget that caught a runaway loop early
  343. JetBrains AI Assistant: First safe refactor that felt genuinely new
  344. Windsurf: Onboarding a new hire with Windsurf already installed
  345. Cursor: First code review after a heavy Cursor day
  346. Google Gemini: First attempt at Vertex evaluations for code tasks
  347. ChatGPT Codex: Measuring what Codex actually merged, not what it attempted
  348. Claude Code: Learning to pause the agent on purpose
  349. GitHub Copilot: Onboarding a junior engineer with Copilot already in the seat
  350. Local LLMs with Ollama: Cost-per-token in wall time, discovered by accident
  351. Agentic coding: Deliberate agent downtime as an early productivity discovery
  352. MCP servers: Teaching the team MCP through a single example server
  353. AI coding workflows: Daily checklist that outlasted two tool migrations
  354. Prompt engineering for code: Shorter prompts after a month of deliberately deleting words
  355. Cline and Roo Code: What closed-source agents still did better, and where they did not
  356. JetBrains AI Assistant: Teaching Junie through existing Markdown docs
  357. Windsurf: Write mode restraint in the first month of use
  358. Cursor: Learning to write intent in comments, not in chat
  359. Google Gemini: Honest cost of long-context prompts in a small team
  360. ChatGPT Codex: Small playbook that made Codex predictable
  361. Claude Code: Moment Claude Code beat a human reviewer on taste
  362. GitHub Copilot: First model switch inside Copilot Chat, and what it taught us
  363. Local LLMs with Ollama: Air-gapped development as a serious practice, not a demo
  364. Agentic coding: First PR an agent opened that we merged without edits
  365. MCP servers: What the protocol gave us and what our product still had to
  366. AI coding workflows: First retrospective on what AI did and did not change
  367. Prompt engineering for code: First prompt rot we detected, and the lessons from it
  368. Cline and Roo Code: Quiet pleasure of reading every tool call
  369. JetBrains AI Assistant: Early taste tests: JetBrains AI versus the newcomers
  370. Windsurf: Windsurf setting that changed how we reviewed code
  371. Cursor: Pricing tier choices with incomplete information
  372. Google Gemini: First real comparison we ran between Gemini and the rest
  373. ChatGPT Codex: Choosing Codex for upgrades, humans for design
  374. Claude Code: Slash commands as the first real team workflow
  375. GitHub Copilot: When to lean on Copilot CLI instead of the IDE extension
  376. Local LLMs with Ollama: Pairing Ollama with Continue for a first private IDE setup
  377. Agentic coding: Cost-per-merged-change metric we invented out of necessity
  378. MCP servers: First MCP server a security review actually approved
  379. AI coding workflows: Diff as primary artefact, chat as exhaust, a first lesson
  380. Prompt engineering for code: How we measured prompt quality before we had metrics
  381. Cline and Roo Code: First month of honest logs from an open-source agent
  382. JetBrains AI Assistant: First CI run with Junie as a contributor
  383. Windsurf: First MCP server we plugged into Windsurf
  384. Cursor: Undoing Cursor changes on purpose, a first discipline
  385. Google Gemini: When to ask Gemini and when to open the logs yourself
  386. ChatGPT Codex: First time we stopped Codex mid-task and why
  387. Claude Code: When headless Claude Code became part of our CI
  388. GitHub Copilot: Measuring Copilot adoption without lying to ourselves
  389. Local LLMs with Ollama: Offline code reviewer that survived a flaky Wi-Fi week
  390. Agentic coding: Long-running agent that finally paused itself
  391. MCP servers: Observability gaps that bit us exactly once
  392. AI coding workflows: Acceptance tests first, agents second, as a beginner mantra
  393. Prompt engineering for code: Style guides for both humans and models, a beginner attempt
  394. Cline and Roo Code: Running Cline against a local LLM for the first time
  395. JetBrains AI Assistant: When Junie finished the task we had been avoiding
  396. Windsurf: Beginner comparison: Windsurf, Cursor, VS Code Agent
  397. Cursor: MCP inside Cursor as an early glimpse of the toolbelt
  398. Google Gemini: Writing Mermaid diagrams Gemini could then critique
  399. ChatGPT Codex: Budgeting Codex tasks when usage was still a black box
  400. Claude Code: Turning a chaotic commit history into a tidy narrative
  401. GitHub Copilot: Premium request debate, before anyone had real data
  402. Local LLMs with Ollama: Caching embeddings locally for a beginner RAG
  403. Agentic coding: How a junior engineer earned their first autonomous task
  404. MCP servers: Versioning MCP servers like APIs, a first-year habit
  405. AI coding workflows: Choosing boredom over brilliance in the first year
  406. Prompt engineering for code: When a prompt quietly became a feature spec
  407. Cline and Roo Code: Memory banks as a beginner experiment in agent continuity
  408. JetBrains AI Assistant: Pairing Code With Me with AI Assistant for remote review
  409. Windsurf: Pausing Cascade versus pausing yourself
  410. Cursor: When agent mode decided to write tests we never wrote
  411. Google Gemini: Verbosity we trimmed in month two
  412. ChatGPT Codex: Diff-first review habit we learned from Codex
  413. Claude Code: First time Claude Code said no to a bad instruction
  414. GitHub Copilot: Discovering Copilot Edits and rethinking the pull request
  415. Local LLMs with Ollama: Moment a local 7B beat the cloud on a real task
  416. Agentic coding: Case for suggest-only agents in safety-critical code
  417. MCP servers: First sandboxing policy we wished we had started with
  418. AI coding workflows: Shutdown routine that made AI-heavy days survivable
  419. Prompt engineering for code: Diffing prompts without a system, and the system that followed
  420. Cline and Roo Code: Picking models per task with almost no data, and learning fast
  421. JetBrains AI Assistant: AI Assistant versus plain inspections on the same codebase
  422. Windsurf: First atomic commit authored entirely by Cascade
  423. Cursor: First week we stopped fighting Cursor and let it drive
  424. Google Gemini: Mixing AI Studio and Code Assist without losing context
  425. ChatGPT Codex: When Codex rewrote code we did not ask it to
  426. Claude Code: Running Claude Code on a legacy repo nobody wanted to touch
  427. GitHub Copilot: First .github/copilot-instructions.md that actually shipped
  428. Local LLMs with Ollama: Local evaluations that predicted our first cloud regression
  429. Agentic coding: Short loops as the winning rhythm, discovered through long ones
  430. MCP servers: Why we promoted an internal wiki to an MCP resource
  431. AI coding workflows: Time-boxing agent loops before they ate the afternoon
  432. Prompt engineering for code: Prompt library we started in a shared Markdown file
  433. Cline and Roo Code: First audit trail that made a security lead smile
  434. JetBrains AI Assistant: Beginner workflow with Junie, ADRs, and module scope
  435. Windsurf: Writing our first Cascade-friendly task spec
  436. Cursor: Indexing hiccups on a monorepo larger than the demo
  437. Google Gemini: IAM audits with Gemini: the day it noticed what we missed
  438. ChatGPT Codex: Scoping tasks to finish in a single pass, a beginner lesson
  439. Claude Code: Hooks as a cheap gateway drug to workflow automation
  440. GitHub Copilot: Why @workspace changed how we wrote issues
  441. Local LLMs with Ollama: Quantisation choices with incomplete information
  442. Agentic coding: First rollback plan we actually used
  443. MCP servers: Composing agents over a tiny catalogue of shared tools
  444. AI coding workflows: Rescue patterns discovered after the first agentic disaster
  445. Prompt engineering for code: Few-shot examples drawn from our own first PRs
  446. Cline and Roo Code: Cline tool manifests we shared with colleagues over lunch
  447. JetBrains AI Assistant: First inspection the agent actually listened to
  448. Windsurf: Windsurf defaults we kept and the ones we overrode
  449. Cursor: Composer for the first multi-file refactor we trusted
  450. Google Gemini: First migration we ran through a single long prompt
  451. ChatGPT Codex: First Codex PR that shipped without a human touch
  452. Claude Code: Cost spike that taught us to checkpoint
  453. GitHub Copilot: Copilot Chat in the terminal versus the editor, a first look
  454. Local LLMs with Ollama: Thermal limits on the first serious local code session
  455. Agentic coding: Guardrails before autonomy, learned the expensive way
  456. MCP servers: First auth model we picked, and later regretted
  457. AI coding workflows: Scorecard that replaced vanity metrics in month three
  458. Prompt engineering for code: Role prompts the first time we stopped cosplaying with them
  459. Cline and Roo Code: Roo modes that encoded our first team conventions
  460. JetBrains AI Assistant: Refactoring across types with AI Assistant and not losing sleep
  461. Windsurf: What the first long Cascade session actually cost
  462. Cursor: Tab predict surprises that made us rewrite comments
  463. Google Gemini: Gemini CLI as a weekend scripting partner
  464. ChatGPT Codex: Parallel tasks and the temptation to scope too wide
  465. Claude Code: Sub-agents the first time they saved an afternoon
  466. GitHub Copilot: Early art of rejecting suggestions without hurting velocity
  467. Local LLMs with Ollama: Private RAG pipelines, assembled out of a weekend of curiosity
  468. Agentic coding: Planning outputs as the real product of the initial turn
  469. MCP servers: Early protocol tour, done with a plain JSON-RPC client
  470. AI coding workflows: Pair-with-AI rituals for a team that had never tried them
  471. Prompt engineering for code: Structured outputs, discovered the hard way
  472. Cline and Roo Code: Plan mode as a cheap insurance policy from day one
  473. JetBrains AI Assistant: Structural search as the hidden rail for early prompts
  474. Windsurf: Moment Windsurf made a skeptical reviewer pause
  475. Cursor: Agent mode as a faster, more honest pair programmer
  476. Google Gemini: Multimodal debugging with a single screenshot
  477. ChatGPT Codex: Sandbox surprises in the first month of Codex
  478. Claude Code: Planning mode as the training wheels we kept
  479. GitHub Copilot: When inline completion earned its place in the daily loop
  480. Local LLMs with Ollama: Picking a local model for code without benchmarks to lean on
  481. Agentic coding: Budgets as the first feature any agent had to have
  482. MCP servers: Exposing read-only resources before we dared expose actions
  483. AI coding workflows: Small reversible steps as a rhythm we borrowed from elsewhere
  484. Prompt engineering for code: Learning that acceptance criteria beat cleverness
  485. The Hidden Power of Automation in Building a $1K MRR Application
  486. Cline and Roo Code: Bring-your-own-key in the early days of model pricing
  487. JetBrains AI Assistant: Junie arrives: the first autonomous task we trusted
  488. Windsurf: Flows as a new way to carry intent across files
  489. Cursor: Writing a .cursorrules file that did not embarrass us
  490. Google Gemini: Gemini Code Assist versus the API, a first year comparison
  491. ChatGPT Codex: Writing AGENTS.md for a team that had never used agents
  492. Claude Code: Writing your first CLAUDE.md and learning what to leave out
  493. GitHub Copilot: Teaching Copilot your repository one readme at a time
  494. Local LLMs with Ollama: First week running Ollama on a work laptop
  495. Agentic coding: First overnight agent run we dared to approve
  496. MCP servers: First MCP server that earned its keep
  497. AI coding workflows: First weekly review that made AI-assisted work sustainable
  498. Prompt engineering for code: First prompts we wrote that still pass review a year later
  499. Cline and Roo Code: First open-source agent we actually trusted
  500. JetBrains AI Assistant: AI Assistant day one in a JetBrains shop
  501. Windsurf: First look at Cascade after a year of Cursor
  502. Cursor: First hour inside Cursor after years of VS Code
  503. Google Gemini: First million-token prompt we actually sent
  504. ChatGPT Codex: First Codex task that opened a real pull request
  505. Claude Code: First week of Claude Code at the terminal
  506. GitHub Copilot: First honest week with GitHub Copilot on a real codebase
  507. Local LLMs with Ollama: Teaching a team to trust a model they own end to end
  508. Agentic coding: What agentic coding taught us about how we really work
  509. MCP servers: First comparison between MCP and home-grown tool plumbing
  510. AI coding workflows: What we retired because an agent finally did it well
  511. Prompt engineering for code: Prompt engineering as writing, not programming
  512. Cline and Roo Code: Teaching juniors by pairing on Cline sessions
  513. JetBrains AI Assistant: Writing specs tight enough for Junie to execute cleanly
  514. Windsurf: Retrospective after our first Windsurf-heavy sprint
  515. Cursor: Teaching Cursor the house style without a wall of prose
  516. Google Gemini: Gemini for Workspace as the quiet engineering multiplier
  517. ChatGPT Codex: Pairing Codex with tight acceptance criteria for the first time
  518. Claude Code: First pass at measuring Claude Code against ordinary coding
  519. Building A Micro SaaS That Actually Pays Rent
  520. GitHub Copilot: Small refactor Copilot did not quite nail, and why it mattered
  521. Local LLMs with Ollama: First honest benchmark between local and cloud models
  522. Agentic coding: Retrospective after our first week of full agentic coding
  523. MCP servers: Testing MCP servers with the same rigor as customer-facing APIs
  524. AI coding workflows: When taking the keyboard back was the real productivity move
  525. Prompt engineering for code: Honest taxonomy of prompts, as discovered in practice
  526. Cline and Roo Code: Plan mode budget that caught a runaway loop early
  527. JetBrains AI Assistant: First safe refactor that felt genuinely new
  528. Windsurf: Onboarding a new hire with Windsurf already installed
  529. Cursor: First code review after a heavy Cursor day
  530. Google Gemini: First attempt at Vertex evaluations for code tasks
  531. ChatGPT Codex: Measuring what Codex actually merged, not what it attempted
  532. Claude Code: Learning to pause the agent on purpose
  533. GitHub Copilot: Onboarding a junior engineer with Copilot already in the seat
  534. Local LLMs with Ollama: Cost-per-token in wall time, discovered by accident
  535. Agentic coding: Deliberate agent downtime as an early productivity discovery
  536. MCP servers: Teaching the team MCP through a single example server
  537. AI coding workflows: Daily checklist that outlasted two tool migrations
  538. Prompt engineering for code: Shorter prompts after a month of deliberately deleting words
  539. Cline and Roo Code: What closed-source agents still did better, and where they did not
  540. JetBrains AI Assistant: Teaching Junie through existing Markdown docs
  541. Windsurf: Write mode restraint in the first month of use
  542. Cursor: Learning to write intent in comments, not in chat
  543. Google Gemini: Honest cost of long-context prompts in a small team
  544. ChatGPT Codex: Small playbook that made Codex predictable
  545. Claude Code: Moment Claude Code beat a human reviewer on taste
  546. GitHub Copilot: First model switch inside Copilot Chat, and what it taught us
  547. Local LLMs with Ollama: Air-gapped development as a serious practice, not a demo
  548. Agentic coding: First PR an agent opened that we merged without edits
  549. MCP servers: What the protocol gave us and what our product still had to
  550. AI coding workflows: First retrospective on what AI did and did not change
  551. Prompt engineering for code: First prompt rot we detected, and the lessons from it
  552. Cline and Roo Code: Quiet pleasure of reading every tool call
  553. JetBrains AI Assistant: Early taste tests: JetBrains AI versus the newcomers
  554. Windsurf: Windsurf setting that changed how we reviewed code
  555. Cursor: Pricing tier choices with incomplete information
  556. Google Gemini: First real comparison we ran between Gemini and the rest
  557. ChatGPT Codex: Choosing Codex for upgrades, humans for design
  558. Claude Code: Slash commands as the first real team workflow
  559. GitHub Copilot: When to lean on Copilot CLI instead of the IDE extension
  560. Local LLMs with Ollama: Pairing Ollama with Continue for a first private IDE setup
  561. Agentic coding: Cost-per-merged-change metric we invented out of necessity
  562. MCP servers: First MCP server a security review actually approved
  563. AI coding workflows: Diff as primary artefact, chat as exhaust, a first lesson
  564. Prompt engineering for code: How we measured prompt quality before we had metrics
  565. Cline and Roo Code: First month of honest logs from an open-source agent
  566. JetBrains AI Assistant: First CI run with Junie as a contributor
  567. Windsurf: First MCP server we plugged into Windsurf
  568. Cursor: Undoing Cursor changes on purpose, a first discipline
  569. Google Gemini: When to ask Gemini and when to open the logs yourself
  570. ChatGPT Codex: First time we stopped Codex mid-task and why
  571. Claude Code: When headless Claude Code became part of our CI
  572. GitHub Copilot: Measuring Copilot adoption without lying to ourselves
  573. Local LLMs with Ollama: Offline code reviewer that survived a flaky Wi-Fi week
  574. Agentic coding: Long-running agent that finally paused itself
  575. MCP servers: Observability gaps that bit us exactly once
  576. AI coding workflows: Acceptance tests first, agents second, as a beginner mantra
  577. Prompt engineering for code: Style guides for both humans and models, a beginner attempt
  578. Cline and Roo Code: Running Cline against a local LLM for the first time
  579. JetBrains AI Assistant: When Junie finished the task we had been avoiding
  580. Windsurf: Beginner comparison: Windsurf, Cursor, VS Code Agent
  581. Cursor: MCP inside Cursor as an early glimpse of the toolbelt
  582. Google Gemini: Writing Mermaid diagrams Gemini could then critique
  583. ChatGPT Codex: Budgeting Codex tasks when usage was still a black box
  584. Claude Code: Turning a chaotic commit history into a tidy narrative
  585. GitHub Copilot: Premium request debate, before anyone had real data
  586. Local LLMs with Ollama: Caching embeddings locally for a beginner RAG
  587. Agentic coding: How a junior engineer earned their first autonomous task
  588. MCP servers: Versioning MCP servers like APIs, a first-year habit
  589. AI coding workflows: Choosing boredom over brilliance in the first year
  590. Prompt engineering for code: When a prompt quietly became a feature spec
  591. Cline and Roo Code: Memory banks as a beginner experiment in agent continuity
  592. JetBrains AI Assistant: Pairing Code With Me with AI Assistant for remote review
  593. Windsurf: Pausing Cascade versus pausing yourself
  594. Cursor: When agent mode decided to write tests we never wrote
  595. Google Gemini: Verbosity we trimmed in month two
  596. ChatGPT Codex: Diff-first review habit we learned from Codex
  597. Claude Code: First time Claude Code said no to a bad instruction
  598. GitHub Copilot: Discovering Copilot Edits and rethinking the pull request
  599. Local LLMs with Ollama: Moment a local 7B beat the cloud on a real task
  600. Agentic coding: Case for suggest-only agents in safety-critical code
  601. MCP servers: First sandboxing policy we wished we had started with
  602. AI coding workflows: Shutdown routine that made AI-heavy days survivable
  603. Prompt engineering for code: Diffing prompts without a system, and the system that followed
  604. Cline and Roo Code: Picking models per task with almost no data, and learning fast
  605. JetBrains AI Assistant: AI Assistant versus plain inspections on the same codebase
  606. Windsurf: First atomic commit authored entirely by Cascade
  607. Cursor: First week we stopped fighting Cursor and let it drive
  608. Google Gemini: Mixing AI Studio and Code Assist without losing context
  609. ChatGPT Codex: When Codex rewrote code we did not ask it to
  610. Claude Code: Running Claude Code on a legacy repo nobody wanted to touch
  611. GitHub Copilot: First .github/copilot-instructions.md that actually shipped
  612. Local LLMs with Ollama: Local evaluations that predicted our first cloud regression
  613. Agentic coding: Short loops as the winning rhythm, discovered through long ones
  614. MCP servers: Why we promoted an internal wiki to an MCP resource
  615. AI coding workflows: Time-boxing agent loops before they ate the afternoon
  616. Prompt engineering for code: Prompt library we started in a shared Markdown file
  617. Cline and Roo Code: First audit trail that made a security lead smile
  618. JetBrains AI Assistant: Beginner workflow with Junie, ADRs, and module scope
  619. Windsurf: Writing our first Cascade-friendly task spec
  620. Cursor: Indexing hiccups on a monorepo larger than the demo
  621. Google Gemini: IAM audits with Gemini: the day it noticed what we missed
  622. ChatGPT Codex: Scoping tasks to finish in a single pass, a beginner lesson
  623. Claude Code: Hooks as a cheap gateway drug to workflow automation
  624. GitHub Copilot: Why @workspace changed how we wrote issues
  625. Local LLMs with Ollama: Quantisation choices with incomplete information
  626. Agentic coding: First rollback plan we actually used
  627. MCP servers: Composing agents over a tiny catalogue of shared tools
  628. AI coding workflows: Rescue patterns discovered after the first agentic disaster
  629. Prompt engineering for code: Few-shot examples drawn from our own first PRs
  630. Cline and Roo Code: Cline tool manifests we shared with colleagues over lunch
  631. JetBrains AI Assistant: First inspection the agent actually listened to
  632. Windsurf: Windsurf defaults we kept and the ones we overrode
  633. Cursor: Composer for the first multi-file refactor we trusted
  634. Google Gemini: First migration we ran through a single long prompt
  635. ChatGPT Codex: First Codex PR that shipped without a human touch
  636. Claude Code: Cost spike that taught us to checkpoint
  637. GitHub Copilot: Copilot Chat in the terminal versus the editor, a first look
  638. Local LLMs with Ollama: Thermal limits on the first serious local code session
  639. Agentic coding: Guardrails before autonomy, learned the expensive way
  640. MCP servers: First auth model we picked, and later regretted
  641. AI coding workflows: Scorecard that replaced vanity metrics in month three
  642. Prompt engineering for code: Role prompts the first time we stopped cosplaying with them
  643. Cline and Roo Code: Roo modes that encoded our first team conventions
  644. JetBrains AI Assistant: Refactoring across types with AI Assistant and not losing sleep
  645. Windsurf: What the first long Cascade session actually cost
  646. Cursor: Tab predict surprises that made us rewrite comments
  647. Google Gemini: Gemini CLI as a weekend scripting partner
  648. ChatGPT Codex: Parallel tasks and the temptation to scope too wide
  649. Claude Code: Sub-agents the first time they saved an afternoon
  650. GitHub Copilot: Early art of rejecting suggestions without hurting velocity
  651. Local LLMs with Ollama: Private RAG pipelines, assembled out of a weekend of curiosity
  652. Agentic coding: Planning outputs as the real product of the initial turn
  653. MCP servers: Early protocol tour, done with a plain JSON-RPC client
  654. AI coding workflows: Pair-with-AI rituals for a team that had never tried them
  655. Prompt engineering for code: Structured outputs, discovered the hard way
  656. Cline and Roo Code: Plan mode as a cheap insurance policy from day one
  657. JetBrains AI Assistant: Structural search as the hidden rail for early prompts
  658. Windsurf: Moment Windsurf made a skeptical reviewer pause
  659. Cursor: Agent mode as a faster, more honest pair programmer
  660. Google Gemini: Multimodal debugging with a single screenshot
  661. ChatGPT Codex: Sandbox surprises in the first month of Codex
  662. Claude Code: Planning mode as the training wheels we kept
  663. GitHub Copilot: When inline completion earned its place in the daily loop
  664. Local LLMs with Ollama: Picking a local model for code without benchmarks to lean on
  665. Agentic coding: Budgets as the first feature any agent had to have
  666. MCP servers: Exposing read-only resources before we dared expose actions
  667. AI coding workflows: Small reversible steps as a rhythm we borrowed from elsewhere
  668. Prompt engineering for code: Learning that acceptance criteria beat cleverness
  669. Cline and Roo Code: Bring-your-own-key in the early days of model pricing
  670. JetBrains AI Assistant: Junie arrives: the first autonomous task we trusted
  671. Windsurf: Flows as a new way to carry intent across files
  672. Cursor: Writing a .cursorrules file that did not embarrass us
  673. Google Gemini: Gemini Code Assist versus the API, a first year comparison
  674. ChatGPT Codex: Writing AGENTS.md for a team that had never used agents
  675. Claude Code: Writing your first CLAUDE.md and learning what to leave out
  676. GitHub Copilot: Teaching Copilot your repository one readme at a time
  677. Local LLMs with Ollama: First week running Ollama on a work laptop
  678. Agentic coding: First overnight agent run we dared to approve
  679. MCP servers: First MCP server that earned its keep
  680. AI coding workflows: First weekly review that made AI-assisted work sustainable
  681. Prompt engineering for code: First prompts we wrote that still pass review a year later
  682. Cline and Roo Code: First open-source agent we actually trusted
  683. JetBrains AI Assistant: AI Assistant day one in a JetBrains shop
  684. Windsurf: First look at Cascade after a year of Cursor
  685. Cursor: First hour inside Cursor after years of VS Code
  686. Google Gemini: First million-token prompt we actually sent
  687. ChatGPT Codex: First Codex task that opened a real pull request
  688. Claude Code: First week of Claude Code at the terminal
  689. GitHub Copilot: First honest week with GitHub Copilot on a real codebase