“This is what engineering means,” I thought.
The trigger was a video of Lauren Tan discussing development with AI agents. She uses the handle poteto and created pstack, a plugin for engineering workflows.
Agents working while their operator sleeps make an appealing headline. What interested me was the work needed before that delegation became possible: giving agents tools to check their results, making repeated mistakes harder to introduce, and making that foundation useful to other people.
This article is an editorial summary of the important ideas, with practical explanations. It is not a full transcript. The Japanese edition includes brief translated excerpts.
The post and the attached video describe different things
The post describes agents delivering code while their operator sleeps. It also mentions more than 21 agents, an 85% internal adoption figure, and a Chief of Staff coordinator.
Those figures and that coordinator description were not found in the English automatic captions attached to this particular 56-minute, 52-second video. The recording focuses on verification skills, observing failures, restructuring the development environment, and enforcing constraints in CI. The post’s promotional introduction should not be treated as a verbatim account of everything said in the video.
The timestamps below refer to the video in this X post. Its automatic captions were read throughout, and names such as pstack and Grok Bot were checked against official material. Automatic transcription can still contain errors.
Who is poteto?
Poteto is Lauren Tan’s online handle. In the official pstack README, she describes experience with large codebases at Meta, Netflix, and Cursor, and work on React Compiler as part of the React core team.
The React team page lists her in the Compiler group. It also says that she studied finance rather than computer science and learned to code using Excel.
Her 2020 essay about leaving Netflix discusses her experience as an engineering manager, including shaping a team and creating conditions in which people can thrive. That background makes her management analogy for agents particularly interesting.
Her X profile, checked on October 11, 2026, mentions work on Grok Bot. The React page still lists Cursor. Public profiles can reflect different update dates, so this article does not assign her a current formal job title.
Give the agent a way to check its work
Around 05:47, Tan identifies verification as the essential skill for working with agents. She means running the actual application, exercising it as a user would, and collecting evidence such as performance traces or memory snapshots when needed.
If every change requires a person to open the app, reproduce the problem, and copy errors back to the agent, that person becomes the bottleneck. A verification tool lets the agent connect its implementation to an observable result and return to the fix when the result differs.

This is an editorial simplification. Verification of behavior does not automatically establish good design or a delightful experience.
For a save-button fix, for example, useful evidence might include pressing the button, checking the saved content, and reloading to confirm persistence. That is an illustration added by this article, not a claim about a particular demonstration in the video.
Tools also need a map of the product
Around 10:12, Tan explains Feature Maps. An agent may be able to control the app and still have no idea how to reach the relevant feature.
A feature map connects the feature’s purpose, the route a user takes to it, the actions required to exercise it, and the result that demonstrates success.
The official verification-skill instructions pair an app-driving tool with this user-facing map. They also require executing the generated instructions once and preserving evidence.
The useful artifact is a reliable entrance to the work: if someone reports a problem here, the agent knows where to go and what to observe.
pstack grew out of observed failures
From around 13:44, Tan describes building skills incrementally. An agent would confidently identify a cause without reading the relevant code, or get lost while navigating the product. She turned recurring failures into reusable procedures.
Skills are primarily Markdown instructions. pstack packages these engineering procedures as a Cursor plugin. Its official guide asks the operator to describe the desired outcome and how completion will be checked; /poteto-mode routes that work through an appropriate playbook.
Around 18:51, the discussion turns to evaluating the skills themselves. Adding instructions is not proof that behavior improves. The procedure needs to be tested on tasks and its effects observed.
The work and the instructions for doing the work both need verification.
Move repeated corrections into structure and automatic checks
From around 30:12, Tan discusses reshaping the codebase that agents work in. Around 39:00, she introduces Dune, the internal name for Grok Bot’s architecture. Dune and pstack are distinct. Around 45:20, she describes the architecture as a collection of ideas rather than a library she is offering to open-source.
One example separates work that renders the interface from heavier processing. In an Electron app, importing heavy work into the renderer can make interactions stutter. She describes separating directories and checking forbidden dependencies in CI.
CI runs checks when changes are made. It can reject a violation instead of relying on someone to remember a written warning.

This diagram organizes the idea editorially. It does not imply that every judgment can become an automatic check.
The video also describes banning useEffect and code comments in that particular environment. These are contextual engineering choices, not universal rules to copy into every project.
Around 44:53, Tan explains the aim as making the easiest route through the codebase lead to a good implementation. If agents copy existing patterns and take shortcuts, those patterns and shortcuts should support the desired result.
Overnight work comes after that foundation
Around 03:36, Tan describes agents merging pull requests and her checking the results after waking up. This is her account, not an independent audit of those changes. Merging a PR and deploying to production are also different operations.
Around 24:28, she recommends starting locally, where the operator can observe how an agent interacts with the app. Around 27:20, she warns against jumping to large fleets of cloud agents before building trust, because that can waste money.
The progression is to make one task verifiable, test that process, and then expand delegation.
The current Grok Bot documentation, checked on October 11, 2026, describes persistent cloud execution with a browser, filesystem, and terminal. Bots under the same account share the cloud computer. This current product description should be distinguished from the environment at the time of the recording.
Around 49:34, Tan acknowledges having abundant token access at an AI lab. That resource context matters. A smaller team should measure useful outcomes and usage on a limited task before trying to reproduce the same scale.
Trying the idea on our own Fly Swatter game
After watching the talk, I wondered where to start in my own Codex environment. I chose one bounded task: checking a game from its first screen through the end of a session.
The subject was attrip’s Fly Swatter game. Swat 100 insects, defeat the boss, clear three stages, and move on to the next round.
Turn completion into a reusable skill
We first created game-save-resume-check, then game-flow-check for starting, basic controls, ending, saving, and resuming. These are custom Markdown instructions for Codex.
They tell the agent to identify the game discussed immediately before the request, find its launch instructions and user-facing routes, define observable success, perform normal input, and save screenshots, recordings, and a result report. If the target is ambiguous, it asks. Procedure repairs are limited to two, and unchecked behavior stays unchecked.
A valid skill file is not evidence that the game works. We went on to use the procedure on the actual game. This was a small application of the talk’s idea: pair a verification tool with a map of how to reach the feature.
The local version worked, but the public version still stopped
The reported problem was that the game stopped after playing once. We clarified the end screen with “Play again” and “Back to title.” But success in the local corrected version did not explain the public-site failure.
Comparing the public code revealed that a numeric animation value was named t, shadowing the translation function t() in the same scope. On taking damage, the drawing code tried to call a number as a function and stopped before scheduling the next frame.
Normal clicks in an isolated local copy of the public code reproduced t is not a function. The corrected version renamed the number to progress; damage, defeat, and recovery rendering were checked, followed by a public-site check that a completed run could be restarted.
Distinguishing the local result from what visitors actually received made the cause observable.
Clear three stages, then keep playing
We then played the public game from the beginning. Automation read the visible insects and recovery items from screenshots and used mouse clicks, or touch drags followed by the “Swat!” button. It did not inject enemies, scores, saved state, or a completed-stage flag.
On October 11, 2026, the Japanese desktop version cleared all three stages and swatted an insect in round two. The English desktop version and both language versions at a phone-sized viewport also cleared three stages. Each then continued for at least 12 seconds in round two: the remaining insects went from 100 to 75 on English desktop, 76 with Japanese touch input, and 77 with English touch input. No rendering stop or JavaScript exception occurred.

The phone-sized checks used a 375px browser viewport and touch emulation, not a physical phone. The verified scope was all three stages of round one and continued input in the first stage of round two. Completing all of round two and long-duration stability remain unchecked.
The save check also followed the actual product contract. This game preserves score history; it does not restore an interrupted board after reloading. We did not invent a resume feature merely to mark a checklist complete.
The verification procedure needed a fix too
The touch procedure initially kept waiting to press “Swat!” after a normal defeat had disabled the button. That was a verification problem, distinct from the game’s rendering bug.
We changed the procedure to return to screen-state checks when an ending or clear disabled the control, and reduced the delay between reading the screenshot and aiming. One procedure repair was enough for both touch versions to clear all three stages. The game itself was not changed for that test.
This experiment brought together a route to the feature, observable completion, evidence from normal input, and a way to improve the procedure after failure. It applied pstack’s ideas to one task in our existing Codex setup. We did not install pstack itself or perform an independent skill evaluation.
Instead of repeatedly asking AI to “check it,” we defined what to operate, what result to observe, and where to preserve the evidence. That procedure can be reused when the next game needs a fix. The engineering idea in the video became something tangible in our own work.
Why this felt like engineering
Here is my interpretation.
What interested me was creating a foundation for the next task and the next contributor, as well as finishing the current task.
If the agent cannot find the feature, build a map. If it cannot observe the result, build a verification tool. If the same mistake keeps returning, move the constraint into the structure or an automatic check.
Around 54:31, Tan describes designers and product managers contributing through that environment. This is her description, not a measured productivity study. Still, the direction is compelling: turn personal speed into conditions that help other people build.
For my own work, I would start with one feature and write down how to reach it, what completion looks like, and how to preserve the evidence. For a game, that might mean saving and resuming a session. For an article, it might mean checking that the placed images load and remain readable on a phone.
The value is in creating an environment where AI can check its work and where other people can use that capability with confidence. That is what made me think: this is engineering.
My earlier article on Lauren Tan’s approach discussed roles and boundaries. This video makes the supporting verification tools and enforceable constraints more concrete.











