Plan in Obsidian, build with Claude Code: the PRD-to-tasks loop
How practitioners on r/hermesagent run projects: requirements and task lists in an Obsidian vault, small tasks handed to a coding agent, every diff reviewed by a human.
Tools used
- ObsidianNotes vault for the PRD, tasks and decisions
- Claude CodeCoding agent that reads, edits and tests the repo
- Hermes AgentOptional orchestrator for research, PRD and task hand-off
- VS CodeWhere you review and hand-edit the diff
- GitCheckpoints and small commits
Step navigator
A vault with a PRD, an architecture note, a task list and a changelog, plus a repeatable loop: pick one task, have the agent write, test and document it, then review the diff yourself.
Developers and builders who already use a coding agent and find that bigger projects drift, lose context or end up as one huge diff.
Before you start
This guide mirrors workflows that people described in two r/hermesagent threads. Their main point: they don't start by typing "build this". They write the requirements down, split the work into small tasks, and keep the project knowledge in notes the agent reads before each task. Hermes is optional here. One person used it to write the PRD and hand tasks to the coding agent, and another used OpenCode in the same role. The habits matter more than which tools you pick.
Step-by-step instructions
Write the four planning documents before any code
Create a folder in your Obsidian vault for the project with four notes: PRD, Architecture, UI Specification and Tasks. Fill in the PRD first: what you are building, who it is for, and what is out of scope. The author of the source post says the biggest lesson was "Don't start coding immediately. Spend more time defining what you're building."
Where this comes from: u/Recent-Discipline253 in r/hermesagent: "The real breakthrough wasn't finding a better AI model".
Why this works
Agents fail when requirements live only in your head or in a long chat history.
Collect UI references before the agent designs anything
Add screenshots, mockups and reference links to the UI Specification note. The same author found that when the AI designs everything by itself, "most apps end up looking strangely similar". Setting the visual direction first improved their results.
Where this comes from: u/Recent-Discipline253 in r/hermesagent: "The real breakthrough wasn't finding a better AI model".
Why this works
The agent copies whatever direction you give it, so give it one on purpose.
Break the PRD into phases and small tasks
Turn the PRD into phases, then into small tasks in the Tasks note or on a kanban board. One commenter has Hermes build the PRD, features, modules and subtasks, then parse them into phases on a Hermes kanban, in "logical small chunks with memory/changelog/code rules in Obsidian". If you don't use Hermes, do the same split by hand or ask your coding agent to propose it in plan mode.
Where this comes from: u/NotJustAnyDNA in r/hermesagent: "How are you coding with Hermes?".
Why this works
Small tasks keep each agent session focused, and they produce diffs a person can actually review.
Put the project rules where the agent reads them every session
Write the build, test and lint commands, conventions and "never do X" rules into CLAUDE.md (or AGENTS.md, which Claude Code, Codex and Cursor can all read). Keep it short. Anthropic's guidance is that if Claude already does something correctly without a line, delete the line. In the thread, Obsidian holds the code rules and changelog so that "context and knowledge is read before each task."
Where this comes from: u/NotJustAnyDNA in r/hermesagent: "How are you coding with Hermes?".
Why this works
Persistent rules stop you from re-explaining the same conventions in every session.
Hand one task to the agent: write, test, document
Take the top TO DO task and give it to Claude Code with the relevant notes referenced (for example @docs/PRD.md). Ask for code, tests and a short note in the changelog. For anything that touches several files, start in plan mode (Shift+Tab until the status bar shows plan mode on) and approve the plan before edits.
Another commenter in the same thread had Hermes delegate every coding task to OpenCode and act as the coordinator, with OpenCode implementing, testing and fixing each feature until the MVP was done.
Where this comes from: u/NotJustAnyDNA and u/scross01 in r/hermesagent: "How are you coding with Hermes?".
Implement the task "<task name>" from @docs/Tasks.md. Follow @CLAUDE.md. Write tests for it, run the test suite, and add one line to @docs/CHANGELOG.md describing the change.
Why this works
Each task is small, testable and logged, so the next session starts with accurate context.
Review the diff yourself in your editor
Open the changes in VS Code (or your editor's source control view) and read the diff before you commit. Fix things by hand where that is faster. The commenter's loop ends with "Manual edits and reviews are via VS Code." Then commit, tick off the task and move to the next one.
Where this comes from: u/NotJustAnyDNA in r/hermesagent: "How are you coding with Hermes?".
Why this works
The agent stops when the work looks done. You are the check that it actually is.
End of guide · Reviewed Oct 26, 2026
Pro tips3
- Treat model choice as secondary. The source author found a well-organized workflow with a good model consistently beat a chaotic workflow with a great model.
- Keep the vault as the single place for decisions, so a fresh agent session and a future you read the same thing.
- Commit after every task. That gives you a clean point to revert to if the next task goes wrong.
Common mistakes3
- Saying "build this", then "continue, continue". The source author says this broke down as soon as projects got bigger.
- Letting the notes go stale. If the PRD no longer matches the code, the agent follows the wrong one.
- Making tasks so big that the diff can't be reviewed in one sitting.
FAQ3
Do I need Hermes for this?
Why Obsidian instead of a README?
Is there a way to run Cursor inside Obsidian?
Related field guides.
CodingReview AI-written pull requests against an acceptance contract
A reviewer's method from r/ExperiencedDevs: a short scope contract at the top of the PR, the diff checked against it first, no extra behavior, plus Copilot code review as a first pass.
CodingKeep agent PRs small: one concern per branch
A developer's setup from r/ExperiencedDevs: the agent plans a feature into small chunks, writes the approved plan to the repo, and ships one stacked PR per concern.
CodingShip a feature with a coding agent: spec, tests first, then review the diff
The loop experienced developers describe on r/ExperiencedDevs: write the spec, plan the smallest steps, have tests written from the spec, implement, then review against the spec before anything merges.