What they're up to

  1. November 2026
  2. Tibo
  3. poteto
  4. poteto
  5. poteto
  6. poteto
  7. poteto
  8. Tibo
  9. Tibo
  10. Tibo
    Tibo ·
  11. Tibo
  12. Tibo
  13. Tibo
  14. poteto
  15. Tibo
  16. Tibo
  17. poteto
  18. Tibo
  19. Tibo
  20. Tibo
  21. poteto
    poteto ·
    while i'm quite bullish on formal methods, i think it's worth tempering expectations and doing your own research on it (disclaimer: i am not an expert in it). it cannot guarantee your code is bug free, only that it matches the spec under certain assumptions, and the specs come from what people want, not math. as long as we build software for humans, nothing can prove that your spec is right, only you can judge. i created the /statechart skill in pstack primarily because it helps make the state machines implicit in your code more obvious and legible to you, so you can shrink the review surface and review the work at a higher level: does it actually match your intent and goal? i used this skill a ton while building my game http://tibo.dog, below you can see the statechart for story mode where i was able to find many bugs with it. in that sense, i think model checking (eg TLA+ with TLC) is quite useful for understanding and checking properties of your system e2e, and you don't have to write tons of new verification code for it. the spec isn't your actual code so there's always a risk of drift, but so far i've had good experiences finding actual bugs with it. i tend to pair it with empirical verification (running the code) also to confirm it's real other types of formal verification like proving theorems (eg Lean, Dafny), bounded model checking (eg CBMC, Kani) etc have their own tradeoffs. proofs cover every possible input, but only for the properties specified, and it takes a lot more code/work. bounded model checking can run on your actual code, which avoids drift, but it only checks up to a certain number of steps, so it's better at finding bugs than proving there aren't any so i think in the near-medium term you'll still need to layer your codebase: constraints and guardrails (types, lint rules, api design, refactoring), empirical verification (tests, evals, real usage), and formal verification for the parts that really need it. none of these catch everything on their own, but layered together, they catch a lot more and shrink what's left for you to review but also maybe in the limit, the bitter lesson will prevail and flawless code will just be printed out perfectly every time with no bugs. even in that scenario, /statechart still seems very helpful in confirming that the agent understood your intent correctly. give it a try if you haven't already! https://github.com/cursor/plugins/tree/main/pstack/skills/statechart
  22. Tibo
  23. Tibo
  24. Tibo
  25. Tibo
  26. Tibo
  27. poteto
  28. poteto
  29. Tibo
  30. poteto
  31. Tibo
    Tibo ·
  32. Tibo
  33. poteto
  34. Tibo
    Tibo ·
  35. poteto
  36. Tibo
  37. poteto
  38. poteto
  39. Tibo
  40. Tibo
  41. poteto
  42. October 2026
  43. poteto
  44. poteto
    poteto ·
    here’s a short grok bot guide on how i create high quality bots and manage my team. ask @bot to read this post and help you improve your team! • add dr eggbot to your team! he’s my bot designer that i use to create bots • you don’t need a lot of bots. a few good bots can be more useful and easier to manage than a large team • tell your bots to create skills for itself as you give it instructions on how to do tasks. this lets them do them more consistently even over long conversations. you can even ask it to create a private github repo for you to store all your skills if you want them preserved independently • add connectors, use the vault, and give access to all the tools you use to do your work. you can also ask your bot to setup its own email and it can sign up for its own accounts for better separation • thinking about all the work you do by hand, or steps in your workflows where you have to copy and paste information back to your bot. ask your bot how it can do that for you instead! • imagine you hired an intern, how would you onboard them and help them do the work correctly and efficiently? introduce yourself to your bot and describe the work you do, then ask it how it can help you automate it and my favorite tip: use voice mode or the transcription option! it’s a good way to just brain dump a lot of information. then, at the end, tell your bot to “restate this in your own words” so you can confirm it understood you https://x.ai/bot/_jOdbfkB16zxu7MRcmReE
  45. Tibo
  46. poteto
  47. poteto
  48. Tibo
  49. poteto
  50. Tibo
  51. poteto
  52. Tibo
  53. Tibo
  54. poteto
  55. poteto
  56. poteto
  57. poteto
  58. Tibo
  59. poteto
  60. poteto
  61. poteto
  62. Tibo
  63. poteto
  64. poteto
  65. poteto
  66. poteto
  67. Tibo
  68. Tibo
  69. poteto
  70. Tibo
  71. poteto
  72. Tibo
  73. Tibo
  74. Tibo
  75. poteto
  76. Tibo
  77. poteto
  78. Tibo
  79. poteto
  80. poteto
  81. poteto
  82. Tibo
  83. Tibo
  84. Tibo
  85. Tibo
  86. Tibo
  87. Tibo
  88. poteto
  89. Tibo
    Tibo ·
  90. poteto
  91. poteto
  92. poteto
  93. poteto
  94. poteto
  95. poteto
  96. poteto
  97. poteto
    poteto ·
    something that keeps bothering me is how some people see slop as something that is happening to them, like they're some kind of helpless bystander powerless to do anything about it excuse me but you are a software engineer, you literally learned how to make sand think and make computers do your bidding?! and now you can't do anything about it? please the 2 things you should know to cut through all the noise: 1. you need to give your agent a way to verify its own work (i just posted about this so won't rehash) 2. your codebase is memory the 2nd is not new either, we have always had lint rules, compilers with good diagnostics and strong type systems, LSPs, etc to help us write better code. there is no difference when agents write the code instead, you just need more of them, and stronger ones. forget rules and skills. you can add those later. yes, your codebase is a form of memory to agents! agents love extending what already exists. so every nit and every annoyance you've ever seen, every mistake and bad pattern you observe from agents, needs to turn into a constraint, or the agents will just keep repeating those same mistakes like a virus in your code. then you keep observing and repeating this process until your codebase is locked down enough that even agents with little context can one shot a high quality PR. an even better direction is to refactor/rewrite your code such that agent anti-patterns become categorically impossible. use type systems to your advantage, use libraries/frameworks that reduce the architectural search space, or heck, create your own framework like we did for grok bot and design high quality primitives and well thought out APIs
  98. poteto
  99. poteto
  100. Tibo
  101. Tibo
  102. poteto
  103. poteto
    poteto ·
  104. poteto
  105. poteto
  106. poteto
    poteto ·
    codebases have always contained slop. we have always been okay with this because code rarely needs to be perfect, outside of mission critical "hard" (eg embedded) software. swe is a unique form of engineering because you're often building something that constantly evolves and is almost organic - user tastes change, your mental models evolve, and features come and go. admittedly, i and many others who've been coding for a long time were initially (like back in 2024) skeptical that agents would write production code. "but what about all the slop that would enter our beautiful codebase?". well, even before, we had human slop, and there was a lot of it! if we're being truthful, most people call "code i didn't write" slop. the reality is that 99% of people (i include myself in that number) don't even know what Good Code looks like, let alone be capable of writing it. i would propose that Good Code is: • correct • bug free • fast and cost efficient to run it has always been exceedingly difficult and expensive to write truly Good Code, because for the longest time (maybe @bendlang will change that), code was not something you could cheaply and formally guarantee to have all 3 of these properties. this is why writing hard software is much more difficult and expensive, because depending on the use case, you may only get one chance and so you have to be right from the start. but the vast majority of software we use does not need to be Good Code to provide value to users. in fact, it is very likely that most software we use is not formally verifiable! we accepted some bugs in exchange for velocity and progress, so we rely on tests and o11y instead and have adopted a more incremental approach. this is a good thing! agents help us move faster, and if you're open to the idea, are capable of helping us write better code. it won't be Good Code (that is still expensive), but it is likely to be much better on average at scale. the new craft of swe is to figure out how to do this. it's your job now! if your productivity with and without agents is not significantly different, you're doing something wrong. but it's not too late to embrace it and use it as an opportunity to learn a whole new skill tree
  107. poteto
  108. poteto
  109. poteto
  110. poteto
  111. poteto
  112. poteto
  113. poteto
  114. poteto
  115. poteto
  116. poteto
    poteto ·
    volume does matter look, i get it. if you were an engineer before agents came along, you're rightfully skeptical about lines of code and number of PRs being used as a metric for any kind of productivity. and i agree! or at least, i used to. for ease of explanation i will talk about this from the perspective as being an engineer on a large team of at least 50. volume didn't matter before because we focused on impact. you could have high impact even with a few PRs: for example you could make a one line config change and save the company millions of dollars. but before agents, the times where i saw volume come into the conversation were for the outliers. on the negative end you might have someone who is struggling to perform, on the other end you might have someone who was a "coding machine" archetype. a coding machine was someone who could just lock themselves in a room and emerge with a stack of PRs that solve a huge number of problems. so volume did matter, but only at the tail ends of the distribution, and combined with impact. if you've ever worked at a large tech company before, you'll get what i mean. the thing about agents is that big tech co problems are now small-medium co problems as well. how do agents change this calculus? well, everyone now has the ability to become a coding machine. you have incredibly capable frontier models that can write code better than any of us, at a rate much faster than we can. in this world, if you're still producing the same number of PRs as before, why wouldn't you pause to wonder why you're not being more productive? alien intelligence is here, and yet you can't outship a human coding machine? this brings me back to why i keep talking about trust (https://x.com/poteto/status/2102050467505430555). if you haven't put in the work to trust your agent's output, it is very difficult to scale up your productivity. and yes, this approach does require more tokens, but i think about this in terms of cost per intelligence. before agents, this cost was very high - you needed to hire many software engineers with high 6 figure salaries to do the work. tokens are still expensive today, but are likely to get cheaper over time (https://x.com/theo/status/2107924138094703084) factoring in the cost of intelligence. what looks exorbitant today will likely be affordable in 6 moths to a year. a single engineer with agents can do the work of tens if not hundreds of engineers, at a fraction of the cost. the reality that i don't think has hit yet is that job of the software engineer has truly changed. our job is not merely to produce software any longer (well tbh it was never only about the code, but bear with me for the sake of the explanation), but the machine that writes the software. this idea of a software factory, or a Michelin kitchen as i like to call it, is still a topic of research. and it's the type of stuff i like to share, not to flex, but to show you what's possible when you put a lot of rigor into using agents at scale
  117. poteto
  118. poteto
  119. poteto
  120. poteto
  121. Tibo
  122. Tibo
  123. poteto
  124. poteto
  125. Tibo
  126. Tibo
  127. poteto
  128. poteto
  129. Tibo
  130. Tibo
  131. Tibo
  132. poteto
  133. Tibo
  134. Tibo
  135. poteto
  136. Tibo
  137. Tibo
  138. Tibo
  139. Tibo
  140. poteto
  141. poteto
    poteto ·
    it's easy to fall into the trap of micromanaging your agents instead of correcting the environment that shapes its behavior. pstack 0.15.9 now ships a new /correct skill: if you keep correcting agents for the same mistakes, it finds the pattern and fixes it with architecture, types, and checks. i like to imagine that commits rapidly flowing into the codebase are like a bonsai tree rapidly growing in whatever direction it pleases. what you want to do is not to give in to the chaos, but tame it intentionally with the right constraints 0.15.9 also has improvements to: • /architect: now includes instructions on designing agent friendly architecture • a new /benchmark-checklist skill based on @brendangregg's benchmarking checklist here's a prompt you can give to grok bot to start architecting a better codebase with pstack: /poteto-mode create a new Project agent to refactor and rearchitect my repo so that our architecture is more agent friendly. it should use both the /correct and /architect skill to look through past commits and find the most common pitfalls that agents fall into, whether its with code quality, performance, or bugs. if relevant you can also use the /recall skill to find past conversations for context. it should make a high level plan for me to review. it should also answer its own open questions by prototyping rather than defer to me. come back to me with a plan backed by real data. once i approve the plan, use either the stack or full autopilot playbook (ask me which i want) to execute
  142. poteto
  143. poteto
  144. poteto
  145. September 2026
  146. poteto
  147. Tibo
  148. August 2026
  149. Tibo
  150. poteto
  151. June 2026
  152. Tibo
  153. May 2026
  154. Tibo
  155. Tibo
See the full timeline →