Skip to content
Search

VibeCoding:Tutorial

lastmod 2026-05-13created 2025-07-029 edits

Let's vibe~

Categories

Cursor Settings

  • Save specs (SPEC.md, etc.) as Markdown and include them as context.
  • Add a .cursorignore file to keep the context small.
  • Use .cursor/rules/*.mdc files in the project folder.
  • Use MPC.
  • ollama can also be connected if needed.

Claude Settings

  • CLAUDE.md
  • .claudeignore
  • .claude/settings.json

Key points (using Claude-code usage as an example)

  • Built on three core pillars
    • Specification: define the goal (e.g. "build a Twitter clone with a login feature")
    • Rules: set explicit constraints (e.g. "use Python, avoid complexity")
    • Oversight: monitor the process and ensure consistency
  • Work while understanding the code as a whole.
    • Along with "implement", questions like "why is this needed" should be included.
    • The point is that when reviewing the output, you "ask" about anything you don't understand and understand it before moving on.
  • Work in parallel on utility projects as well
    • Code editor / browser plugins / utility scripts
  • The time to create a CLAUDE.md file is when the LLM won't listen!
    • Team-level knowledge accumulation via CLAUDE.md
      • Keep a single CLAUDE.md file in the Claude Code repository, shared by the whole team
      • Checked into git, with the whole team contributing several times a week
      • Whenever Claude does something wrong, add it to CLAUDE.md to prevent the same mistake next time
      • Other teams maintain their own CLAUDE.md, and each team is responsible for keeping it up to date
    • Update CLAUDE.md during code review
      • During code review, tag @.claude on a colleague's PR to add content to CLAUDE.md as part of the PR
  • Use the Claude Code GitHub Action (/install-github-action)
  • The prompt is "code". If needed, preserve the question/answer process itself.
  • Make active use of "plan mode" when working on the overall task.
  • Apply highly voted skills from Skills ( https://skills.sh/ ).
  • Applying CLAUDE.md, Skills, MCP, etc. indiscriminately burns through tokens very quickly. (Keep checking with /context and /usage.)
  • In the previous era the "code" itself was the asset, but in the AI era the "test cases" are the asset. -> SQLite:Testing#How SQLite is tested
  • Register skills or agents that need to be used in common on a marketplace.
  • Break work down with subagents. In this case, context is not shared in Agent 2 Agent. -> Since the context is not connected, tokens are saved, but the intermediate process is cut off, so answer quality drops somewhat.
    • Use several subagents regularly
      • code-simplifier - simplifies code after Claude finishes its work
      • verify-app - includes detailed instructions for end-to-end testing of Claude Code
  • Agent Teams (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS is in beta as of March 5, 2026) In this case, context is shared in A2A.
  • Operating-related content can also be registered as a subagent.
  • Use Claude Hooks for static checks right after Write and Edit.
  • Use a Notification to announce task completion.
  • If you need straight-through work without questions, use a Background task (&) -> this requires a certain amount of trust to have been built.
  • When using multiple sessions, either split them with tmux or use a related GUI Application.
  • Make active use of file references (@), Commands (/), etc.
  • Make active use of Frontmetter to avoid quality degradation caused by the LLM's trailing-token recognition problem.
  • Provide content that doesn't really need to be referenced as links.
  • Don't make changes mid-run; fix the plan and run again.
    • If you don't like the result, don't keep repeating code change requests.
    • Revise the plan document, then run again in a new session.
    • Changing direction during the execution phase makes quality collapse quickly.
  • Teach style based on examples.
  • For security, operations, and long-term maintenance code, you must understand the whole code. LLMs have the characteristic problem that comprehension drops as the context size grows.
  • Don't ask the AI to change scripts and code you can simply run yourself. -> The indiscriminate stdout/stderr after asking is the culprit that burns tokens.
  • Use tests, linters, and builds as a feedback loop
  • Commit when each task is done, so you can roll back per single Q&A.
  • Split work into extremely small units
  • For repeatable work, use AI to build scripts/tools that do that work. -> What you ask the AI for as output is "the actions needed to reach the goal" rather than "the goal".
  • Measure the quality of AI results by "consistency of the output".
  • Keep asking the AI for "structural completeness" in your requests.
  • If you're short on tokens, pick the model to suit the situation. -> Opus for coding, sonnet for writing commit messages, Haiku for simple translation
  • Don't let cognitive debt (Korean: 인지 부채) pile up, just like technical debt (Korean: 기술 부채).
  • Actually, for simple problems or problems that don't need domain knowledge, AI writes Low-Level Programming Languages like C better.
  • For split work: git worktree vs git checkout -> not sure yet. (I prefer git checkout)
  • Use a Slack MCP or Discord MCP setup so that work related to error fixes can be referenced.
  • When working alone, I tried Claude Code#A mere 65-line Markdown file that tries to fix the LLM coding problems pointed out by Andrej Karpathy. -> The content itself is good too, so give it a look.

See also

author Zer0 sitemap