Coding workflows

When an AI agent trusts the comment and misses the code

Eric Tech's tour of Lauren Tan's pstack follows coding agents through understanding existing applications, comparing designs, verifying changes and questioning their own fixes.

Read the implementation

Suppose a comment says a function returns A, while the implementation returns B. An agent can follow the description and miss what the program does, a hypothetical that Eric Tech uses to explain Lauren Tan's no-comments principle in pstack. As the video's presenter puts it, "this function in the code, it returns B." Removing the comment directs the agent back to the implementation to examine its behavior.

Tan, who Eric Tech identifies as working at Cursor and belonging to the React team, has shared her software development workflows, skills and principles in pstack. The walkthrough arranges its skills around the development life cycle, moving from planning through design, building, testing and deployment to maintenance, with the first stage devoted to understanding the application before changing it.

Eric Tech sees the planning skills as suited to brownfield projects, where code already exists. The how skill explains the implementation and the why skill examines its reasoning, while the teach skill combines those inquiries; for larger assignments, figure-out breaks the work into tickets and show-me-your-work records decisions in a document or Markdown file. Migrations and substantial changes fit this approach, though the presenter prefers planning tools from Matt Pocock or another collection when building from scratch: "But personally, I won't probably use her planning skill".

Compare designs before building

Design brings competing proposals into the process before implementation begins. The architect skill invokes arena, which sends the assignment to multiple agents and models; Eric Tech names Opus, GPT and Grok as possible participants. The interrogate skill then judges the proposals and combines their strongest parts into a report, an arrangement that the presenter contrasts with previously reviewed workflows that rely on a single model.

Building starts with the TDD skill, which directs the agent to write tests first, while a TypeScript best-practice skill supplies implementation rules that Eric Tech connects to Tan's React work. The presenter treats the choice of TDD workflow as dependent on the assignment and the team's practices. Once the code exists, cleanup-diff compares the working branch with main and checks for extra comments, try-catch code, variables without types and deep nesting; tests check that the cleanup preserves behavior, and a short summary records the work.

Exercise the application

Testing extends beyond functional and unit checks to exercising the application as a user would. The create-verification-skill workflow covers launching the application, preparing its environment, database and servers, diagnosing problems, performing user actions and collecting evidence, along with tearing down temporary resources afterward. Feature folders hold steps that run end to end, while the swarm workflow divides the application among agents and gathers their findings into a report. The interrogate skill returns to compare the feature branch with main and try to break the changes; what Eric Tech calls the "thermonuclear code quality review" adds a search for ways to simplify and refactor the implementation.

Follow the change through review

Deployment begins with making the pull request easy to review, although Eric Tech treats its writing style as a developer's preference. The babysit skill follows the request through to a completed merge, while other tools resolve merge conflicts, retrieve review comments and fix failed continuous-integration checks. The presenter illustrates the need with a teammate merging work at the same time and creating a conflict. Maintenance would collect issues and feed them back into planning, but pstack has no corresponding skill for that stage.

Some skills enter whenever the work requires them. A developer can explain a problem to the router, which chooses a skill, while catch-up helps when switching projects and trying to recall what happened. Writing also has dedicated support: alongside Eric Tech's discussion of writing skills, poteto on X recommends /technical-writing.

AI_Reveals on X describes a related arrangement for Claude Code, arguing that project instructions, tool integrations, permission settings, repeatable commands, skills and specialized agents make it more powerful. That post outlines a project structure, while Eric Tech follows the points at which pstack's skills enter a development task; both give skills and agents explicit places in the work.

Question the direction of a fix

Tan also puts principles in skills instead of collecting every rule in a system prompt. Eric Tech explains that, with a large prompt, "every message you send to AI is going to read that system prompt", even when its instructions have little relevance to the task. Separate skills and an index map let the agent select principles when they apply, including a rule for reconsidering a repair that keeps failing.

The attack-the-premise principle addresses a cycle that Eric Tech describes as "fixing and then blocked, fixing and then blocked", with the agent continuing in the same direction while the bug returns. The skill tells it to stop and question its assumption before another attempt; "Are we even on the right track", the presenter asks. Eric Tech wants to add this principle to his own tools.

Another principle concerns the states that a type system permits a program to represent. Eric Tech explains rejecting impossible combinations with a payment, saying a "payment here could not be paid and also pending at the same time." The presenter wants to adopt this rule too, while poteto on X describes work on a companion skill for drawing statecharts and diagrams and checking them against specifications made with /create-formal-verification-skill in pstack. Comparing designs, exercising changes, reconsidering failed repairs and rejecting incompatible states each give the agent a way to examine the work before proceeding.