Skip to content
Back to search

lauren-poteto-rules

Engineering rules for building trustworthy coding-agent workflows, inspired by Lauren Tan.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/unicodef1wn--lauren-poteto-rules/badge.svg)](/listings/unicodef1wn--lauren-poteto-rules)

HTML

<a href="/listings/unicodef1wn--lauren-poteto-rules"><img src="/api/listings/unicodef1wn--lauren-poteto-rules/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Grok Bot

Download [SKILL.md](SKILL.md), attach it to a Grok Bot conversation, and send:

Create a private skill named "Lauren Poteto Rules" from the attached SKILL.md.
Preserve its scope and instructions. Use it for engineering investigation,
implementation, review, and delegation.

After Grok Bot saves it, confirm that **Lauren Poteto Rules** appears under **Marketplace → Your plugins → Manage plugins and skills → Private skills**. Invoke it from the `/` menu when needed.

For a one-off task, attach `SKILL.md` and ask the Bot to follow it without saving a skill.

Grok CLI

Clone the repository into Grok's personal skills directory:

mkdir -p ~/.grok/skills
git clone https://github.com/unicodef1wn/lauren-poteto-rules.git \
  ~/.grok/skills/lauren-poteto-rules

Start a new session and invoke `/lauren-poteto-rules`. To share it only inside one project, place the folder at `.grok/skills/lauren-poteto-rules` in that repository.

Codex

Clone it into the user skills directory:

mkdir -p ~/.agents/skills
git clone https://github.com/unicodef1wn/lauren-poteto-rules.git \
  ~/.agents/skills/lauren-poteto-rules

Start a new Codex session and invoke `$lauren-poteto-rules`. For one repository, use `.agents/skills/lauren-poteto-rules` instead.

Claude Code

Clone it into Claude Code's personal skills directory:

mkdir -p ~/.claude/skills
git clone https://github.com/unicodef1wn/lauren-poteto-rules.git \
  ~/.claude/skills/lauren-poteto-rules

Invoke it with `/lauren-poteto-rules`. For a project installation, use `.claude/skills/lauren-poteto-rules`.

Cursor

Create a project rule with **New Cursor Rule** or **Cursor Settings → Rules**. Choose **Agent Requested**, use this description, and paste the body of [SKILL.md](SKILL.md):

Engineering workflow for evidence-based diagnosis, runtime verification,
durable constraints, and safe delegation.

Project rules live in `.cursor/rules` and can be committed with the codebase. For a simpler project-wide setup, add the instructions to the repository's root `AGENTS.md`.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 101 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: lauren-poteto-rules
  3. description: Use when an engineering task requires diagnosis, runtime verification, correction of recurring agent failures, or coordination of delegated coding work.
  4. ---
  5. # Lauren Poteto Rules
  6. Engineering instructions for Grok Bot, adapted from Lauren Tan's ideas on verification, agent environments, and durable engineering judgment.
  7. ## Agent instructions
  8. Use these rules for engineering investigation, implementation, review, and delegation. Follow the repository's instructions and the user's scope. Apply only the relevant parts: an explanation needs code evidence; a behavior change needs a running check; a typo needs a document check. Creating tooling or evaluating skills is conditional work, not a prerequisite for every task.
  9. ### 1. Pair with the human
  10. Make the work understandable enough to review and maintain.
  11. - For a non-trivial task, state the problem, material assumptions, and what would demonstrate success. Continue with routine choices already covered by the request.
  12. - Explain consequential decisions using relevant code and observed behavior. Give the reviewer enough context to judge the result without reconstructing your session.
  13. - Keep independent changes separable. When writing commits or pull requests, explain why behavior changed so history remains useful for investigation and reversal.
  14. - Optimize for reviewed, working outcomes rather than code volume or pull-request count.
  15. ### 2. Earn trust with evidence
  16. Close the loop between a claim and the running system.
  17. - Before diagnosing a cause, inspect the affected implementation and trace the relevant calls or data flow. Cite the code and observations supporting your explanation. Mark an untested explanation as a hypothesis.
  18. - For a bug, reproduce the reported behavior before fixing it, then repeat the same steps after the change. If reproduction is blocked, report the missing access, input, or environment and what remains uncertain.
  19. - Exercise the interface users depend on: the UI, API, CLI, or device flow. A passing build alone does not prove runtime behavior.
  20. - Match evidence to the claim. A screenshot can show appearance; interaction claims need an exercised sequence. Performance claims need comparable measurements, traces, or profiles.
  21. - Check correctness and engineering quality separately. A passing flow does not establish that the implementation is maintainable or efficient.
  22. ### 3. Make verification repeatable
  23. Give the next agent both a way to operate the app and a way to find the feature.
  24. - Discover and reuse the repository's actual setup, run, test, and diagnostic tools. Never invent a verification command.
  25. - Consult the feature map when available. It should connect a user-visible feature to its entry point, prerequisites, navigation steps, relevant code, and expected result. Confirm the affected entry against the running app.
  26. - If agents repeatedly get lost, capture the verified route for that feature in existing project documentation. Avoid mapping the whole application for one small fix.
  27. - When developing verification tooling, start locally or in another observable environment. Inspect its actions and failures before using it unattended.
  28. - Turn recurring manual checks into reusable procedures when this fits the task. Record setup, inputs, expected outcomes, evidence locations, and cleanup needed. Keep affected procedures current when the product changes.
  29. ### 4. Treat the codebase and history as memory
  30. Agents learn from the examples they find. Today's shortcut can become tomorrow's convention.
  31. - Inspect nearby code and documented conventions before implementing. Use relevant history when the reason for a pattern is unclear.
  32. - Validate a pattern before copying it. Frequency does not make an obsolete workaround correct.
  33. - Fix the underlying cause within scope. If a workaround is necessary, explain its limitation and removal condition.
  34. - Remove temporary scaffolding introduced by your work. Preserve useful explanations of non-obvious constraints; do not turn a one-off review remark into a permanent comment or universal rule.
  35. ### 5. Turn corrections into durable constraints
  36. When the same mistake can recur, improve the environment that permits it.
  37. Choose the smallest effective mechanism:
  38. | Failure | Useful response |
  39. |---|---|
  40. | An invalid state or dependency can be designed out | Constrain the architecture, API, or data model. |
  41. | A bad pattern can be detected mechanically | Add or reuse a type, lint, compiler, or CI check. |
  42. | A decision requires context and judgment | Write a concise project rule or review criterion. |
  43. | The agent lacks a repeatable procedure | Capture the workflow in a skill and evaluate its behavior. |
  44. - Prefer enforceable constraints where feasible. Written rules and automated review remain fallible guidance.
  45. - Verify that a new check rejects the bad case and permits a valid case.
  46. - Record the general principle and when it applies. Omit the incident's names and history. Extend existing instructions rather than accumulating duplicates.
  47. - Follow the target project's constraints. Lauren's project-specific bans on comments or `useEffect` do not establish universal bans.
  48. - Keep broader architectural changes as a scoped follow-up when they exceed the task.
  49. ### 6. Keep the supported path healthy
  50. Make the shortest route to an implementation follow the intended design.
  51. - Use the canonical helper or module when it meets the need. If it lacks a capability, consider a scoped improvement before adding a competing implementation.
  52. - If several patterns conflict, inspect their usage and constraints before selecting one.
  53. - During maintenance, update obsolete examples and callers together. If existing debt cannot be removed yet, consider preventing new instances while tracking existing exceptions.
  54. - In a new project, establish a minimal working example and enforce important boundaries before agents replicate the first implementation across features.
  55. ### 7. Evaluate rules and skills
  56. Apply this when creating or changing agent instructions or verification workflows.
  57. - Start with an observed failure and define the behavior that should improve. Skills should grow from evidence about how agents work.
  58. - Use representative tasks and observable criteria: did the agent inspect relevant code, exercise the flow, and provide valid evidence? Include a routine task to detect unnecessary process. A dedicated evaluation framework is optional.
  59. - Compare behavior before and after the change when practical. Inspect tool calls, edits, and artifacts, not the agent's confidence or a score alone.
  60. - Keep expected answers out of the evaluated agent's task. Use fresh sessions and the intended model and environment where available.
  61. - Inspect failures and refine the smallest relevant instruction or tool. Re-run affected cases after changes. If execution is unavailable, label the revision untested rather than claiming improvement.
  62. ### 8. Scale only what you can verify
  63. Increase autonomy after the verification loop works reliably.
  64. - Before expanding unattended work, demonstrate that one representative task can be investigated, implemented, exercised, and reviewed using available tools.
  65. - When delegating, pass the repository and revision, scope, relevant instructions, verification procedure, and expected evidence. Make ownership explicit for parallel work.
  66. - Inspect returned changes and evidence. Verify the integrated result when independent changes can interact; a worker's completion message alone is insufficient.
  67. - Preserve the user's existing action boundaries. Successful verification does not grant additional permission.
  68. ### Completion report
  69. Finish with the result, checks actually performed, accessible evidence, and any material limits. Keep it proportional to the task. Distinguish observed results from hypotheses and worker-reported results from checks you performed yourself.
README.md · README · 120 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ![Lauren Poteto's skill for your Grok Bot](assets/cover.png)
  2. # Lauren Poteto Rules
  3. A portable engineering skill inspired by [Lauren Tan's](https://x.com/poteto) talks about working with coding agents.
  4. It teaches an agent to inspect before diagnosing, verify behavior in the running product, turn repeated corrections into durable constraints, and increase autonomy only after the verification loop works.
  5. ## What it changes
  6. - **Evidence before confidence.** A diagnosis must come from relevant code and observed behavior.
  7. - **Run the product.** Builds and type checks do not prove a user flow works.
  8. - **Make verification reusable.** Record how to reach and exercise important features.
  9. - **Treat the codebase as memory.** Agents copy existing patterns, including bad ones.
  10. - **Improve the environment.** Prefer architecture, types, lint rules, and CI over repeated review comments.
  11. - **Evaluate agent instructions.** Change skills in response to observed failures and test the resulting behavior.
  12. - **Scale trust gradually.** Delegate more work only when results remain reviewable and reproducible.
  13. Read the complete instructions in [SKILL.md](SKILL.md). See [EXAMPLES.md](EXAMPLES.md) for concrete failure modes and expected behavior.
  14. ## Install
  15. ### Grok Bot
  16. Download [SKILL.md](SKILL.md), attach it to a Grok Bot conversation, and send:
  17. ```text
  18. Create a private skill named "Lauren Poteto Rules" from the attached SKILL.md.
  19. Preserve its scope and instructions. Use it for engineering investigation,
  20. implementation, review, and delegation.
  21. ```
  22. After Grok Bot saves it, confirm that **Lauren Poteto Rules** appears under **Marketplace → Your plugins → Manage plugins and skills → Private skills**. Invoke it from the `/` menu when needed.
  23. For a one-off task, attach `SKILL.md` and ask the Bot to follow it without saving a skill.
  24. ### Grok CLI
  25. Clone the repository into Grok's personal skills directory:
  26. ```bash
  27. mkdir -p ~/.grok/skills
  28. git clone https://github.com/unicodef1wn/lauren-poteto-rules.git \
  29. ~/.grok/skills/lauren-poteto-rules
  30. ```
  31. Start a new session and invoke `/lauren-poteto-rules`. To share it only inside one project, place the folder at `.grok/skills/lauren-poteto-rules` in that repository.
  32. ### Codex
  33. Clone it into the user skills directory:
  34. ```bash
  35. mkdir -p ~/.agents/skills
  36. git clone https://github.com/unicodef1wn/lauren-poteto-rules.git \
  37. ~/.agents/skills/lauren-poteto-rules
  38. ```
  39. Start a new Codex session and invoke `$lauren-poteto-rules`. For one repository, use `.agents/skills/lauren-poteto-rules` instead.
  40. ### Claude Code
  41. Clone it into Claude Code's personal skills directory:
  42. ```bash
  43. mkdir -p ~/.claude/skills
  44. git clone https://github.com/unicodef1wn/lauren-poteto-rules.git \
  45. ~/.claude/skills/lauren-poteto-rules
  46. ```
  47. Invoke it with `/lauren-poteto-rules`. For a project installation, use `.claude/skills/lauren-poteto-rules`.
  48. ### Cursor
  49. Create a project rule with **New Cursor Rule** or **Cursor Settings → Rules**. Choose **Agent Requested**, use this description, and paste the body of [SKILL.md](SKILL.md):
  50. ```text
  51. Engineering workflow for evidence-based diagnosis, runtime verification,
  52. durable constraints, and safe delegation.
  53. ```
  54. Project rules live in `.cursor/rules` and can be committed with the codebase. For a simpler project-wide setup, add the instructions to the repository's root `AGENTS.md`.
  55. ## Use it
  56. Give the agent a bounded engineering task and the real project context:
  57. ```text
  58. Use Lauren Poteto Rules for this task.
  59. Repository: <repository or working directory>
  60. Task: <the behavior to investigate or change>
  61. Expected result: <observable outcome>
  62. Constraints: <scope or actions requiring approval>
  63. ```
  64. A useful completion report states the result, the checks actually performed, the evidence, and anything still unverified.
  65. ## Evaluate it
  66. Run the same tasks in fresh sessions with and without the skill. Compare actions and artifacts:
  67. - Did the agent inspect the relevant code before naming a cause?
  68. - Did it reproduce the bug or clearly explain the blocker?
  69. - Did it exercise the affected user flow?
  70. - Can another engineer repeat the verification?
  71. - Did the change stay within scope?
  72. - Did a small task remain small?
  73. Use several runs. Judge tool calls, diffs, and evidence rather than the agent's confidence.
  74. ## Credits
  75. The engineering principles are adapted from talks by [Lauren Tan (@poteto)](https://x.com/poteto). The wording, structure, installation guide, and examples are an independent community adaptation by [unicodef1wn](https://x.com/unicodef1wn).
  76. Inspired by the compact packaging of [andrej-karpathy-skills](https://github.com/multica-ai/andrej-karpathy-skills). This is not an official Lauren Tan, xAI, Cursor, Anthropic, or OpenAI release.
  77. ## License
  78. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.