VibeWise passed all 40 tests in our sandbox at commit eefb53d. Its documented purpose is to make you work out how a feature should behave before an AI agent implements it. Choose it for practice making design decisions while building. Developers prioritizing a quick, familiar repair and learners seeking practice writing code themselves should choose another workflow. The distinction is the exercise: VibeWise puts the learner in charge of reasoning while the agent writes the implementation.
Design confirmation leaves code changes pending
VibeWise's documented Design checkpoint records a decision and continues planning; its Implementation checkpoint authorizes specific code changes. The upstream VibeWise README distinguishes both from Build checkpoints, where the learner reasons through the problem. This gives you a useful question to ask during a session: are you agreeing that a design makes sense, or asking the agent to change the code? The workflow gives those decisions different names.
The README illustrates the distinction with a notes app. A note can belong to several folders, so deleting a folder raises a question: should its notes disappear from their other folders too? The learner changes the proposed behavior and chooses a links table that records folder membership while keeping each note separately. Upstream labels the later implementation steps illustrative. The example explains how a design discussion leads to an implementation decision.
| Checkpoint | Your decision | Meaning for code changes |
|---|---|---|
| Build | Explain your approach and reason through consequences | Work through the problem |
| Design | Choose Confirm and continue | Record the design and continue planning |
| Implementation | Choose Implement this step | Authorize the stated changes |
These are not three compulsory stops for every task. The README says an Implementation checkpoint can also confirm the design when it is ready. Beginners receive smaller reasoning questions and explanations; advanced users receive questions about constraints, failure modes and assumptions. Checkpoint frequency is a separate preference. An experienced developer exploring an unfamiliar database can therefore request architectural questions with fewer introductory explanations, following the documented customization model.
What people use vibe-wise for
The supplied reports describe three uses: participating in feature design, adapting the workflow to Codex, and requesting its checkpoints in Cursor. Each concerns a different part of the adoption decision. The demonstration shows the intended learning activity, the Codex adaptation shows a contributor carrying that activity into another package, and the Cursor request shows someone wanting it in their everyday editor. Together they explain why the teaching method and installation route both matter.
- The project author demonstrated planning a Notion clone with and without VibeWise, according to daily.dev's demonstration summary. The account contrasts default Claude supplying an implementation plan with VibeWise asking about scope, data modeling, edge cases and architecture.
- GitHub user djolex999 reported adapting VibeWise into an external Codex skill in the issue #14 port announcement. The author said the learning model and notes format were unchanged.
- The requester in the issue #13 Cursor discussion praised the design checkpoints and reasoning before code, then asked for the workflow in their everyday IDE.
For an initial evaluation, choose one feature whose behavior you can explain in ordinary language. Folder deletion is useful because shared notes force a concrete decision about what survives. Explain the outcome you want, discuss the proposed data model, and compare the implementation report with the decision you approved. This suggested exercise puts the README's teaching sequence into a task small enough to inspect without turning the evaluation into an entire application build.
What happened when we ran it
Our run at commit eefb53d passed all 40 pytest tests in 9 seconds, with 0 failures. Installation succeeded in 7 seconds and the build succeeded in 1 second on 13 November 2026. These were source checks. A separate hands-on deployment attempt failed its safety step because the harness required a Compose file and the repository contained none of the accepted filenames.
| Source check, 13 November 2026 | Recorded result |
|---|---|
| Install | Succeeded in 7 seconds |
| Dependencies | 35 recorded, 38 MB on disk |
| Build | Succeeded in 1 second |
| Tests | Succeeded in 9 seconds: 40 passed, 0 failed |
| pip-audit | 0 known vulnerabilities |
| Checkout | 24 files, approximately 765 source lines, 0.2 MB |
| Repository signals | Tests directory present, 0 CI workflow files, no Dockerfile |
The recorded sandbox configuration was 3 CPUs, 8 GB RAM and image ghcr.io/astral-sh/uv:python3.12-bookworm. The checkout and dependency figures describe that source-check environment. Upstream separately says normal plugin use requires no extra Python packages. Those are different installation contexts: one records the environment used for checking the source, while the other describes the prerequisites for using the plugin through a coding agent.
The hands-on safety failure names four missing candidates: compose.yaml, compose.yml, docker-compose.yaml and docker-compose.yml. Its error calls the repository unsafe under a rule requiring a Compose file. That finding records a failed prerequisite for the deployment harness. The README's installation route is an agent plugin, which explains why the harness rule belongs alongside the error rather than becoming a general judgment about the product.
The hands-on run summary says deployment used the project's own Docker Compose stack on 2026-11-13, with every port bound to 127.0.0.1. That statement conflicts with the missing-Compose safety failure. The hands-on teardown record reports cleanup as okay. The records therefore contain a failed safety step, a contradictory deployment summary and an okay teardown outcome, alongside the successful source checks.
Where people get stuck
The supplied issue discussions concern bringing VibeWise into preferred coding tools and recovering learning context between sessions. The current README documents upstream Claude Code and Codex plugins; the discussions also cover external adaptations and proposed integrations. For troubleshooting, start with the package you installed and its learning command. That connects a report to the instructions it concerns instead of treating every VibeWise integration as the same installation.
| Reported problem | Practical next step | Status in the supplied evidence |
|---|---|---|
| Cursor user wants the same checkpoints | Read issue #18's reference to proposed PR #17 | Port proposal tracked |
| External Codex skill loses learning context | Invoke that skill again using its own instructions | Manual workaround described in issue #18 |
| OpenCode user wants the workflow | Read the external port linked in issue #23 | Announced as unofficial |
| Checkpoints interrupt a quick task | Ask for fewer checkpoints or pause learning | Documented customization |
| Learning notes should stay out of Git | Add .vibe-wise/ to .gitignore yourself | Documented user action |
GitHub issue #18 tracks ports and a proposed session-restoration adapter. Its supplied exchange describes invoking the external Codex skill again at session start or after losing context, then proposes restoring context automatically. The proposal concerns resuming the learning discussion. The upstream README gives a direct instruction for its Codex plugin: run $vibe-wise:learn at each session start and whenever learning mode loses its context.
GitHub issue #23 announces an unofficial OpenCode port. GitHub issue #21 requests contribution and governance documents, including a code of conduct, contributing guide, security policy and issue/PR templates. These are useful starting points for contributors: one discusses an integration already announced outside the upstream repository, while the other lists specific documentation someone wants added to the project.
Claude Code and Codex have documented upstream routes
The upstream README documents plugin installation for both Claude Code and Codex. Claude Code has an Anthropic Directory route and a GitHub marketplace alternative; Codex has marketplace and plugin commands run from a terminal. Both lead to starting learning mode inside a project. The table keeps those maintained instructions alongside the other routes mentioned in the supplied discussions, with their ownership and status attached.
| Environment | Route described by the source | What to read before choosing |
|---|---|---|
| Claude Code | Upstream plugin | Current README's directory and marketplace instructions |
| Codex | Upstream plugin; external skill also reported | Current README for the plugin, issue #14 for the external skill |
| Cursor | Port proposed in the issue tracker | Issues #13 and #18, including the reference to PR #17 |
| OpenCode | Unofficial external port | Issue #23 and the linked project's instructions |
| Antigravity | Integration request and open PR cited | Issue #18; the separate MCP port also advertises this client |
The README requires an up-to-date Claude Code or Codex installation and Python 3. Claude Code uses Python for context restoration and resetting learning notes; in Codex, only reset needs it. Upstream's learning invocation is /vibe-wise:learn in Claude Code and $vibe-wise:learn in Codex. The external Codex skill described in issue #14 uses $vibe-wise. That command difference is a practical way to recognize which package a set of instructions addresses.
Learning notes enter the agent's context
VibeWise stores preferences, learning notes and a project map in .vibe-wise/, and upstream says saved notes enter the AI's context. The README advertises no extra account, backend or telemetry, while retaining the coding agent's normal data settings. For someone considering the plugin, the relevant distinction is between where the notes are stored and how the agent uses them: the directory is local, and its saved contents become model context.
In a Git repository, the documented notes location is the repository root, including when you work from a subfolder. Without Git, it is the folder where you start. Upstream asks users to add .vibe-wise/ to .gitignore themselves when they want notes excluded from version control. The plugin says it will not silently make that change, so this is a setup decision to make before accumulating project learning notes.
The reset instructions describe a confirmation before backing up the profile, progress and project map inside the notes directory's backups/ folder and restarting onboarding. Upstream says source code and other projects stay untouched. Changing experience level or preferences is a separate action that can be requested directly from the AI. Use a preference change to adjust the discussion; use reset when you intend to start the project's learning record again.
VibeWise vs default Claude Code, Learning Output Style, and VibeWise MCP
VibeWise's documented exercise is reasoning about software behavior and design while the agent implements the result. The alternatives below differ in the learner's activity or the delivery mechanism. Default Claude Code supplies the underlying coding agent; Learning Output Style is described in the supplied synthesis as asking the learner to write code; VibeWise MCP advertises tools for the checkpoint workflow. Choose according to the work you want to practice.
| Option | Evidence for the difference | Pick it when |
|---|---|---|
| Default Claude Code | The author's demonstration, summarized by daily.dev, shows Claude supplying the plan | You want the agent to propose an implementation and already have the judgment to assess it |
| VibeWise | Upstream distinguishes reasoning, design confirmation, and implementation approval | You want to practice making the decisions that precede code |
| Anthropic Learning Output Style | The supplied comparison synthesis describes pauses for writing small portions of code | Writing code yourself is the exercise you want |
| yava-code/vibe-wise-mcp | Its README advertises an MCP port and says enforcement moved to tools | You want to evaluate that approach in an MCP-capable agent |
The Claude Code upstream repository describes a coding agent that executes routine tasks, explains code and handles Git workflows. The Claude Code repository supports that description; daily.dev's demonstration summary supplies the narrower comparison about receiving a ready-made plan. The supplied research synthesis attributes the Learning Output Style comparison to Marlon Steiner's review. Its stated teaching activity differs from VibeWise's emphasis on learner reasoning before AI implementation.
The separate VibeWise MCP repository advertises checkpoint tools, including vibe_confirm, and a pending-decision ledger. Its README says enforcement moved from prompts to the tool layer. The installation instructions require Node.js 20+ and an MCP server. That makes it a separate technical choice as well as a teaching option: adopting it means using its server, runtime and client configuration rather than the original plugin's installation commands.
What the available evidence establishes
The source harness records 40 passing tests at eefb53d, while the README explains how learner decisions progress toward implementation. The creator's VibeWise announcement describes Build, Design and Implementation checkpoints followed by an implementation review. Those sources make the intended exercise concrete: explain how something should work, examine the design, approve a step, and read the agent's account of what changed and which checks ran.
The repository reviewed here is nykooi1/vibe-wise. Vibe Workflow's explanation of the name collision identifies VibeWise as a separate learning plugin rather than one of its own skills. That owner and repository name give searchers a direct way to identify the project before installing it. The supplied related-page summaries concern courses, interview preparation, search, interface design, agent workspaces and transcription, rather than this checkpoint adoption decision.
Documentation earns 4/5 under an explicit rubric
The documentation receives 4/5 because the supplied README explains both upstream installation routes, checkpoint meanings, note storage and reset behavior. Our scale assigns 1 to instructions too incomplete to follow, 3 to a usable setup path with material gaps, and 5 to detailed guidance corroborated by a completed workflow. Four credits the detailed instructions; the final section explains the missing workflow evidence that keeps the rating below five.
Setup ease, community and maturity are unassessed. The supplied GitHub repository metadata records 4,353 stars and 24 open issues and PRs on 13 November 2026, with a last push dated 9 October 2026. Stars describe attention, and the push date describes repository activity. The documentation score instead rests on specific material a reader can use: installation steps, checkpoint decisions, customization, storage and reset instructions.
Questions people ask
VibeWise's upstream README describes Claude Code and Codex plugins, three checkpoint types and project learning notes. The questions below focus on identifying the package, finding the relevant integration discussion and choosing the learning activity. The earlier tables provide the installation and comparison detail; these answers give the shortest useful route back to that information without repeating the full compatibility explanation for every agent mentioned in the research.
What is the vibe-wise plugin, and where is its GitHub repository?
VibeWise asks the learner to reason about behavior and design before an AI agent implements the agreed work. The VibeWise GitHub repository contains the upstream instructions and code. Its notes-and-folders example shows why this matters: deciding what folder deletion should do comes before choosing the membership model and approving the operation that implements it. The learner supplies and reviews those decisions.
Is vibe-wise a skill or a Claude Code plugin?
Upstream documents Claude Code and Codex plugins; issue #14 describes an external Codex adaptation as a skill. For installation, use the instructions belonging to your selected repository. The upstream Codex plugin starts learning with $vibe-wise:learn, while the external skill uses $vibe-wise. Within the learning workflow, the important documented distinction is between discussing an approach, recording a design and authorizing implementation.
Can I use VibeWise with Codex, Antigravity, or other coding agents?
Codex has an upstream installation route in the README. Antigravity appears in issue #18's port-tracking discussion, OpenCode has an announced unofficial port in issue #23, and the MCP repository advertises several clients. Use the compatibility table to locate the relevant instructions or discussion. It labels upstream plugins, external ports and proposals so you can start with the route that matches your agent.
Can I use VibeWise in Cursor IDE?
Issue #18 references a proposed Cursor port in PR #17, following the request in issue #13. The separate VibeWise MCP README also includes Cursor configuration. Start with the proposed port discussion if you want to follow that contribution, or the MCP repository if you want to assess its server approach. The latter requires Node.js 20+ and its own installation steps.
Can VibeWise restore its learning context automatically after a Codex session starts or compacts?
The upstream Codex instructions tell users to run $vibe-wise:learn at each session start and when learning context is lost. Issue #18 discusses an optional restoration adapter. The README says the learning command resumes saved notes without repeating setup, making it the documented action to take when returning to a project. The proposed adapter concerns automating that recovery rather than replacing the learning record.
Is there a structured way to learn while building with Claude instead of accepting all its code?
VibeWise documents reasoning checkpoints, design discussion, implementation approval and an implementation report. Its customization instructions include fewer checkpoints, multiple-choice questions and pausing learning. Choose that exercise when you want practice deciding how software works while the agent writes it. If your goal is to write the code yourself, use a workflow built around that activity rather than treating design discussion as equivalent practice.
What we have not tested yet
Our source checks cover commit eefb53d, not a completed Claude Code or Codex learning session. They do not establish learning gains, reliable prevention of premature edits, or behavior across restarts and compaction. The upstream plugins, external skill, Cursor proposal, OpenCode port, Antigravity integration and MCP port were not exercised inside their target agents. The supplied extracts also leave acceptance of the proposed integrations unresolved and provide no independent enforcement test.
The failed Compose safety step supplied no interactive task results, known-answer questions, runtime memory measurements or screenshots. Actual runtime and operating-system versions require raw toolchain logs; the configured image label is insufficient. The audit's 0 known vulnerabilities is its recorded result rather than a security guarantee. Retention over weeks, explanation quality across models, support response times and adversarial approval enforcement remain outside the measured work.
The supplied metadata contains no latest-release value, and the lookup outcome is unknown. The learning study discussed in the coverage concerns AI-assisted learning generally, not a VibeWise experiment; the creator also says the plugin does not replace learning to code. The issue #18 restoration discussion separates recovering context from implementation permission: restart or compaction must not count as approval. Rendered layout, related links, recommendation modules and template content remain untested.
A useful next experiment would ask the plugin to help design one feature, restart before implementation approval, and observe whether discussion resumes without code edits. After approving and implementing the step, the learner could explain the result without saved notes. These are proposed observations, not completed tests. They would examine the learning workflow and preservation of a pending decision more directly than another source build.


