Commit & Close: finish your step from the IDE — commit, push, and move the task forward
Finish your part once. When you mark a task Done in the IDE, Vi commits your changes with the task ID, pushes them if the repository has a Git remote, marks your current workflow step as finished, moves the task to the next step, and updates the board — one action replaces the whole "update the ticket" ritual.
Done in VS Code. Board updated automatically — the 40-second Commit & Close demo.
The code is done. The board doesn't know.
Developers finish the code, but the project board stays outdated — because updating the ticket is a separate, manual step in a browser tab. Someone has to find the ticket, change its status, write a note, and get back to the editor. Multiply that by every task, every developer, every day, and the tracker becomes a fiction that managers chase in standups.
How Commit & Close works
The developer picks a task in the IDE and clicks Start — it becomes their one active In Progress task. If there are uncommitted changes from other work, Vi offers to stash them first, so they don't end up in this task's commit.
When their part of the work is ready, they mark the task as Done — still inside the IDE.
Vi lists the changed files with checkboxes — the files you already staged are preselected, otherwise all of them — and creates a task-aware commit like "[#142] Fix auth bug" with exactly the files you keep checked.
If the repository has a Git remote, Vi pushes the commit to it — part of the same action. If the push fails, the task does not move: it stays on its current step as "Awaiting push" until you choose Done again and the push succeeds. When the push is refused because a teammate pushed first, Vi offers "Pull and push again": it pulls the way your Git configuration says (a merge by default), pushes, and moves the task on; a conflict is left for you to resolve.
Vi marks the developer's current step as finished and moves the task to the next step of your workflow — Review, QA, approval, or whatever comes next. The task closes only when it passes the final step.
The project board updates automatically. Managers see real status — no chasing.
Why it matters
Developers stay in the IDE
No tab switching, no hunting for tickets. The whole task lifecycle happens where the code is written.
Managers see real status
The board reflects what actually shipped, because updating it is part of shipping — not a favor someone remembers to do.
Git and workflow stay connected
Every commit is linked to its task, so history, reviews, and tickets always line up.
Less context switching
Fewer manual ticket updates means more uninterrupted coding time — every day, for every developer.
One active task per developer
Vi enforces a focused execution model: each developer can have only one task In Progress at a time. Commit & Close finishes the developer's part of that task and frees the slot for the next one. The result is less parallel unfinished work, an accurate workload picture, and a board where "In Progress" actually means in progress.
Your code never leaves your machine
All Git operations that Commit & Close performs — staging, committing, and pushing — run locally on the developer's machine through the Vi IDE extension. Vi never accesses, stores, or uploads source code. It orchestrates the task workflow; your repository stays yours.
Where you can use Commit & Close
- VS Code — Available
- Visual Studio — Available
- RAD Studio 13 — Available
- Lazarus — Available
- JetBrains IDEs — Planned
Working in VS Code? See how Vi works as a VS Code project manager, from task to commit to the next workflow step.
Frequently asked
What is Commit & Close?
Commit & Close is Vi's workflow action for finishing your part of a task: a developer marks a task as Done from the IDE, and Vi creates a task-aware commit, pushes it if a Git remote is configured, marks the developer's current workflow step as finished, moves the task to the next step, and updates the project board automatically.
Does Vi access my source code?
No. All Git operations run locally on the developer's machine through the Vi IDE extension. Vi never accesses, stores, or uploads source code — it only orchestrates the task workflow.
Can Commit & Close push changes to Git?
Yes — if the repository has a Git remote configured, Commit & Close pushes the task-aware commit as part of the same action, so a developer never leaves the IDE to commit or push; without a remote, the commit stays local. If the push fails, the task stays on its current step until it succeeds, so the next person in the workflow never receives work whose code isn't on the remote. When it is refused only because a teammate pushed first, one click on "Pull and push again" pulls, pushes, and moves the task on. All Git operations run locally on the developer's machine through the Vi IDE extension, which is available today for VS Code, Visual Studio, RAD Studio 13, and Lazarus.
Can a developer have multiple tasks in progress?
No. Vi enforces one active In Progress task per developer. This focus rule prevents parallel unfinished work and keeps the board an accurate picture of what is actually being worked on.
What happens after a task is marked Done?
Done marks the end of the developer's work on the current workflow step, not the end of the task. Vi commits the changes with the task ID, pushes them if a Git remote is configured, and moves the task to the next step — for example a Review step with its approval chain, if your workflow defines one. The task is closed only when it passes the final step of the workflow.
Does Commit & Close update the project board?
Yes. The task moves to the next step of your workflow and the project board updates automatically — managers see real project status without anyone editing tickets in a browser.
Can developers still push manually?
Yes. Commit & Close doesn't replace your normal Git tools — developers can still commit and push from the terminal or their IDE's own Git features at any time, and the Vi extensions for RAD Studio and Lazarus also include a Git panel. A normal commit or push doesn't move the task; only Done does.
Is Commit & Close only a Git feature?
No. Commit & Close is part of Vi's project management workflow. It connects code completion to task status, workflow movement, board updates, and project visibility.
Keep exploring: from customer request to delivered code · Git-aware project management · project management in VS Code · IDE project management · source code security