How I AI: Lee Robinson's Workflows for Resilient Code with Cursor and Sharper Writing with ChatGPT

Lee Robinson treats AI coding agents less like magic and more like junior engineers with access to good tooling. His main advice is surprisingly traditional: give the model strong feedback loops through types, linting, formatting, tests, and repeatable review checks. He applies the same philosophy to writing by maintaining a running list of phrases, structures, and habits he wants ChatGPT to flag or avoid.

Before he joined Cursor to teach developers how to work with coding agents, Lee worked on Vercel and Next.js. In this episode of How I AI, he demonstrates the workflows directly inside Cursor and ChatGPT, including how he reviews AI-generated code and how he edits AI-assisted writing without flattening his own voice.

The coding workflow combines typed languages, linting, formatting, tests, and a reusable code-review command that runs against a branch. The writing workflow starts with Lee’s own rough draft, then uses ChatGPT as an editor that highlights generic language, repeated AI patterns, and stylistic habits he wants to remove.

In both cases, the key idea is the same: the model performs better when it can compare its output against an explicit standard. Cursor can rerun lint commands and tests after editing code. ChatGPT can compare a draft against a list of banned phrases and structural patterns. The model can surface likely problems, but a person still has to review the output and decide whether the change is actually good.

Using Cursor to create tighter feedback loops for code

Lee’s setup gives Cursor concrete pass-or-fail signals instead of vague instructions like make this better. The tools come from standard software engineering practice, but they become even more useful when an AI agent can execute them automatically, read the results, and iterate on its own. The checks only cover known classes of problems, though. Passing lint or tests does not mean the code is correct, secure, or appropriate for the product.

As Lee puts it, "There are tools that you can take from traditional software engineering and apply them to make your code more resilient to errors and help the AI models fix errors for you."

Build guardrails before handing work to the agent

Lee recommends setting up quality checks inside the repository before relying heavily on an agent. The agent can only respond to the feedback the project exposes; useful signals give it a much better chance of correcting itself.

1. A Typed Language: Using a language like TypeScript instead of plain JavaScript adds strict rules about data types. This helps catch bugs early and gives both you and the AI immediate feedback when something’s off.
2. Linters: Lee describes linters as automated reviewers for the rules your project has chosen. In the demo, Cursor reads lint failures directly from the terminal output and uses them as actionable feedback for the next revision.
3. A Formatter: A code formatter automatically standardizes how your code looks, indentation, spacing, line breaks, and so on. This keeps everything consistent and makes the code easier for anyone to read, including an AI.
4. Tests: Tests matter even more once AI starts generating large amounts of code. Lee’s workflow relies on rerunning tests after changes so the model can inspect failures, revise the implementation, and verify that expected behavior still works.

Once those systems are in place, Cursor’s agent can inspect the repository, discover the available commands, run them independently, and revise its own work. That feedback loop is what makes the workflow resilient. Anything outside the scope of those checks still requires human review, broader QA, and security evaluation.

Let Cursor diagnose and fix a real failure

Lee’s demo intentionally starts with a repository that already contains problems. Instead of manually searching through files, he gives Cursor a short instruction and lets the agent determine the steps for itself. The simplicity of the prompt is part of the point.

He tells the agent to fix the lint errors.

fix the lint errors

Cursor inspects the repository, discovers the lint command, runs it in the terminal, reads the failures, edits the affected files, and reruns the command to confirm the fix. One issue involved an overly broad any type, which the agent replaced with a more specific type definition.

Lee emphasizes that he never specified which files to inspect or which commands to run. The agent inferred the workflow from the repo itself. He compares the experience to entering a destination into GPS navigation instead of writing step-by-step driving directions.

• Execution: The agent saw that the project had a linting command and ran it in the terminal: bun run lint.
• Analysis: It read the output from that command, which pointed out two specific errors, including a type issue where a variable was incorrectly labeled as any.
• Correction: The agent went to the right file and made the necessary code changes to fix the errors.
• Verification: After editing the files, the agent reruns bun run lint and confirms that the configured checks now pass.

One useful part of this workflow for newer developers is visibility. Cursor exposes the diff and commands it ran, turning the tool into a learning environment as well as a coding assistant. Lee still reviews the output and runs broader tests before merging. The resilient Cursor codebase workflow shows how executable checks guide the agent without replacing review.

Turn recurring review criteria into a reusable command

Lee also maintains custom commands inside Cursor for recurring review tasks. One of them runs a code review against the current branch using a prompt that has evolved over time as he noticed patterns worth checking repeatedly.

To do this, he uses the @ menu in Cursor's agent to pull in all his current changes with @branch. The prompt then tells the AI to review those changes against a specific checklist:

Review all the changes I have on my branch (@branch). Were there any changes here that could affect if the application is running offline? Did we add good tests? Did we make any changes to authentication?

The value of the command is consistency. Instead of relying on memory, Lee encodes recurring concerns directly into the workflow and reruns them whenever he is preparing changes. It works as a structured first-pass reviewer that can surface suspicious edits, performance risks, security concerns, or weak test coverage before another human even looks at the branch.

He is careful not to oversell it. The command is not equivalent to a senior engineer or a dedicated security audit. It simply makes review easier by catching predictable categories of issues early.

Using ChatGPT as a writing linter instead of a ghostwriter

Lee uses a long reusable prompt inside the ChatGPT macOS app to edit drafts across emails, blog posts, documentation, and marketing copy. The prompt is less about generating prose from scratch and more about removing weak patterns. He uses it to identify filler, generic launch language, overused structures, and wording that sounds mechanically AI-generated.

Build a personal list of phrases you repeatedly delete

The writing workflow starts with a running list of words, phrases, and stylistic habits Lee tends to cut during editing. Instead of manually giving the same feedback every time, he turns those preferences into reusable instructions.

Some entries came from writing books or editing advice he found elsewhere. Others are personal annoyances that accumulated after reviewing too much AI-assisted copy.

His examples include unsupported superlatives, vague claims of innovation, generic excitement about launches, filler phrases, and formal verbs that make sentences longer without making them clearer. The goal is not to ban personality. It is to remove language that sounds interchangeable with every other AI-generated announcement on the internet.

• One rule specifically removes canned declarations of excitement and asks the draft to state the actual news or benefit directly.

The workflow is useful even without AI involvement. Keeping a written list of recurring edits makes your own habits easier to notice. Lee updates the prompt whenever he catches himself repeatedly deleting the same kind of wording.

Flag the sentence structures that make AI writing obvious

Lee also tracks larger structural patterns that make drafts feel synthetic. During the conversation, both Lee and I point out that modern models often overuse recognizable rhythms and formatting habits even when the underlying content is solid.

His prompt tells the model to watch for recurring patterns like:

• The phrase: "It's not just X, it's Y."
• Overusing long dashes as a default connective structure, especially when every sentence starts sounding rhythmically identical.
• Using numbered lists for everything (e.g., "First, do this. Second, do this...").

I add a few of her own tells to the list, including unnecessary bullet-heavy formatting and short affirmation phrases that many models repeat automatically. The interesting part of this discussion is that neither of them argues for eliminating these structures entirely. They are useful sometimes. The point is to notice when the pattern is serving the reader versus when the model is defaulting into familiar habits.

Start with your own draft, then use AI as the reviewer

Lee’s actual writing process is intentionally human-first. He usually begins by dumping ideas into a note or recording a voice memo while walking. If he has low energy, he might ask AI for a rough first draft just to react against. More often, though, he writes the first version himself and then asks ChatGPT to review it.

He compares the process directly to software linting. The AI is not replacing authorship. It is checking the draft against explicit style rules and surfacing likely violations.

The workflow stays lightweight:

1. Human-First Draft: He starts by getting his own ideas down, sometimes with a voice note or just a quick brain dump. He writes the first draft in his own style.
2. AI as Reviewer: He then puts his draft into ChatGPT along with his mega prompt.
3. Review the suggestion: ChatGPT flags banned phrases, repetitive structures, and weaker wording, then proposes tighter alternatives. Lee reviews each suggestion manually and keeps only the edits that preserve the intended meaning and voice.

Lee does not trust the model to produce an authentic voice automatically. The writing mega-prompt workflow starts with a human draft, flags recurring weak patterns, and leaves every suggested edit subject to the writer's judgment.

Good checks make AI output easier to trust

The coding and writing examples end up converging on the same principle. Types, linters, tests, review prompts, banned phrases, and structural rules all convert subjective preferences into visible feedback. Once those standards exist, the model can compare its output against them and revise accordingly.

Neither workflow removes human responsibility. Cursor can rerun lint commands and patch type errors, but it cannot decide whether a feature is strategically correct or secure enough for production. ChatGPT can identify repetitive phrasing, but it cannot fully determine taste, nuance, or authorial intent. The human still owns the final decision.

What is worth copying here is the discipline of externalizing your standards. For code, that means creating executable checks the agent can run independently and verify after every edit. For writing, it means documenting the phrases and structures you instinctively delete during revision.