I figured out the best way to vibe code

Summary of tech concepts + product/workflow guidance (AI “vibe coding”)

1) “Levels” of AI coding → automate the workflow

• Beginner workflow: prompt → wait for agent output → review work → prompt again.
• Expert workflow: automate the whole loop so agents can run recurring tasks with minimal manual prompting.

2) Coding agent tools reviewed / recommended

The speaker claims to have tested multiple “agentic coding” tools and calls out favorites and alternatives:

• Cursor
  • Supports multiple model providers (OpenAI, Anthropic, and Cursor’s own models).
  • Early support for cloud agents.
  • Supports concise agent interactions and “rules/agents” configuration.
• Codex
  • Praised for UI/design and concise command summaries (short “what it did” after running commands).
• Claude Code
  • Mentioned but less used due to quota running out quickly.
• Devin and Factory
  • Mentioned as “fantastic” options with different “harnesses” (pros/cons vary).

3) Rules via agents.md / Claude.md (how to control behavior)

Tools can be instructed using documentation-like files:

• agents.md
  • Defines workflow preferences, commit style, commit messages, “personality,” coding preferences, etc.
• Claude.md
  • Claude-specific equivalent.

Additional notes:

• Cursor integration: rules can be managed in Preferences → rules/skills/sub agents and written into agents.md.
• Cursor can also learn preferences automatically and write them into the agents file.
• Recommendation: create an agents.md per project to lock in the model’s “vibe,” language style, and process.

4) Skills: reusable “slash commands” for repeated actions

The speaker emphasizes skills as the most important part after rules:

If you do something more than once → turn it into a skill.

• Uses off-the-shelf public skills and shows an example:
  • Invoke via / → select a skill (e.g., auto review) → run it.

Skills categories described:

1. Repeated prompts/actions (avoid copy-paste).
2. Domain-specific rules (company style guides, issue templates, etc.).
3. Tool instructions
   • Skills can call executable tools (e.g., how to run tests, select test subsets, use APIs/CLIs).
   • Agents can discover which skills to use at runtime (so you may not need to manually select them every time).
4. Quality gates
   • Define processes like “run tests locally first; require 100% pass rate; fix tests if they fail.”

Example off-the-shelf skill set:

• “Agent Skills” (a GitHub repo described as having 61,000 stars)
  • Covers an opinionated dev cycle from refining ideas/PRDs through implementation, testing, QA, and deployment.
• Installation flow:
  • Paste a URL into the tool to install a skill
  • Sometimes requires a restart.

5) PR review automation with Greptile (sponsored)

The speaker demonstrates review-first automation using Greptile:

• Greptile is connected to new repos.
• When a PR opens, Greptile:
  • Summarizes what changed.
  • Provides a confidence score (0–5) for merge success.
  • Shows which files changed and what edits were made.
  • Produces an issue list and copy-pasteable prompts to fix problems.
  • Includes a flowchart-like view of code changes.

The speaker claims Greptile is used by companies like Nvidia, Zapier, Brex, WorkOS, etc.

6) Automations: trigger-based agent runs (e.g., “PR opened”)

Cursor/Codex have first-class automation features.

Automation consists of:

• Trigger (e.g., GitHub pull request opened)
• Agent instructions/prompt
• Optional memories/tools/MCP servers

Example workflow:

• Trigger on PR open.
• Wait until Greptile comments exist (to handle timing).
• Then iterate through Greptile comments, address them, and push updated code back to the PR.

Cursor may also auto-detect required tools for the automation (e.g., GitHub “comment on pull request” tool).

7) Loops: run repeatedly until a goal is met

A loop has three parts:

1. Trigger to start
2. Repeated action
3. Goal/stop condition

The speaker introduces a free loop library:

• signals.fordfuture.ai/loop-library (hosted on “here.now” mentioned)

Example loop patterns:

• Overnight docs sweep loop: nightly diff between previous day changes and docs → update docs → open PR.
• Sub-50ms page load loop: repeatedly test app pages/modals/sidebars; if any exceed 50ms, optimize queries/website performance; loop continues until performance goal met.
• Production error sweep loop: nightly log scanning; diagnose error; write fix; open PR—assuming strong log coverage.

8) “Best practices” flywheel: tests + docs + logging

The approach pushes for:

• 100% test coverage via automation (if not full coverage, write tests).
• Documentation always up to date via daily automated checks.
• Exhaustive logging (suggests storing logs for ~7–30 days) so agents can fix issues that appear.

9) Cloud agents vs local agents

Key comparisons:

• Cloud agents
  • Isolated environments per agent → better parallelism; less file-conflict risk.
  • Runs many agents without choking local CPU/RAM.
  • Accessible from anywhere (mobile/app).
  • Unique feature example: Cursor can generate video/screenshots of changes an agent made.
• Local agents
  • Faster latency (no environment spin-up delay).
  • More direct control/visibility into files.
  • Often get the newest features earlier than cloud.

Recommendation: lean toward moving workflow to cloud due to parallel-agent benefits.

10) Work trees: prevent multi-agent file conflicts

• A work tree = separate working folder/copy of the repo for an agent.
• Guidance:
  • Prefer one work tree per agent thread to avoid agents writing to the same files and causing chaos.
  • Merge later; conflicts resolved at merge time.

Cursor/Codex support spawning via “new work tree.”

11) Multimodal coding (multi-model workflow via skills)

Motivation:

• Speed and cost: not every step needs the most frontier model.
• Using multiple models can reduce token spend and improve throughput.

Example multi-model pipeline (as a skill):

• Plan the feature with one model after examining the codebase.
• Implement with a model better at coding execution.
• Review the output with another model for an alternative perspective.

12) Unsolved pain point: merging + deploying with many parallel agents

Major “unsolved problem” highlighted:

• When multiple agents merge around the same time, they trigger CI/deploy repeatedly.
• Agents may need to rebase/re-run tests due to new commits.
• Locking/coordination problems cause major delays and repeated work.

Partial mitigation mentioned:

• Batch commits / let one agent combine changes, then deploy once.

Speaker notes:

• Cursor is reportedly building a Git alternative for agent scale deployment, implying the issue persists.

---

Main speakers/sources

• Primary speaker: “I” narrator (the video host/author; not explicitly named in the subtitles).
• Sources/tools mentioned: Cursor, Codex, Claude Code, Devin, Factory, Greptile (sponsor), GitHub, “Agent Skills” GitHub repo, Greptile customer list (e.g., Nvidia, Zapier, Brex, WorkOS).