Video summary

I figured out the best way to vibe code

Main summary

Key takeaways

Technology

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).

Original video