The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Use AgentKanban’s chat commands to create and select work, then let its managed context files and MCP connection keep the selected card available to your VS Code agent. The documented loop is @kanban /new <title>, @kanban /task <task name>, then plan, todo, and implement. Use @kanban /refresh when a session loses context. Task priority is still a human decision: you choose the active card, arrange the board, and decide which agent session runs next. No automatic priority score, due-date optimizer, or independently reordering agent is documented.
What the VS Code–Kanban workflow actually does
AgentKanban is a VS Code extension that links a workspace to a Kanban board. When you select a board and a task, it immediately updates a managed section of AGENTS.md and local board documents. Those files give GitHub Copilot or Claude Code the selected task’s description and working context. The extension also writes MCP configuration so supported agents can read and update board data through tools rather than relying only on pasted chat text.
This creates three connected layers:
- Board state: the card, its status, and its position in your Kanban workflow.
- Workspace context: the managed
AGENTS.mdsection plus.agentkanban/MEMORY.mdand.agentkanban/TECHNICAL.md. - Agent execution: the VS Code agent session that plans, edits files, runs commands, and reports progress.
The connection is persistent, but the agent is not an autonomous project manager. Selecting a task tells the agent what to work on; it does not establish a hidden ranking system for every card. You remain responsible for deciding what is most important and when a card should move.
Recommended Free Tools
Before you start: workspace, board, and agent requirements
Connect the workspace to a board
Install and enable AgentKanban in the VS Code workspace where you intend to work, then connect that workspace to the board you use for the project. The extension maintains local Markdown context for the connected board. If you open a different workspace, verify that it is connected to the intended board before selecting a task; otherwise, the managed context can describe a different project than the files you are editing.
#1 Best Overall
- Read Before You Buy — No Video Output: These adapters support charging and USB 2.0 data transfer, but cannot transmit video signals. Except for standard USB webcams (which use USB data only), they are not compatible with HDMI/DisplayPort cables, video-capable USB-C hubs, or docking stations with video output.
- Convert USB-A Ports to USB-C: Designed to connect USB-C earphones, cables, flash drives, card readers, and other USB-C accessories to standard USB-A ports. Plug-and-play with no drivers or software required.
- Aluminum Alloy Housing: Built with a sturdy aluminum alloy shell that aids in heat dissipation and protects against daily wear and scratches. Designed to maintain a stable and secure connection.
- Compact & Travel-Friendly: The ultra-compact design allows the adapter to stay plugged into your device without blocking adjacent ports or adding bulk, reducing wear and tear on your original USB ports.
- 12-Month Warranty: Backed by a 12-month manufacturer warranty for peace of mind. Designed to meet strict quality control standards for reliable everyday performance.
Use a supported agent harness
The documented integration loads task context into GitHub Copilot and Claude Code. MCP support lets a compatible agent read or update board information directly. If an agent does not support the generated MCP configuration, it can still use the Markdown context in the workspace, but board operations will not be available as agent tools.
Keep Git available for isolated work
The optional @kanban /worktree command creates a task branch and a separate working directory. Use it for broad or risky changes so the agent cannot alter the main workspace while you evaluate its work. The normal Git merge and review process remains the approval boundary.
Create a Kanban task from VS Code
1. Create the card
- Open the connected workspace in VS Code and start an agent chat.
- Enter
@kanban /new <title>, replacing<title>with a concise task name, such asAudit image upload validation. - Confirm that the new card appears on the connected board. Keep the title specific enough that it can identify the task in a later session.
/new is the creation command; it does not itself implement the feature. Treat the resulting card as the durable work item and the agent conversation as one execution session attached to it.
2. Select the task for the current session
- In the same chat, run
@kanban /task <task name>. - Use the task’s board name exactly enough for the extension to identify the intended card if several titles are similar.
- Wait for the extension to update the managed context and local board documents before asking the agent to change code.
Selection is important even when you created the card moments earlier. It establishes which task is active and determines what the agent should treat as the current objective.
3. Inspect the injected context
Review the managed section of AGENTS.md and the relevant files under .agentkanban/. This gives you a visible record of what the agent will receive instead of making the board-to-code connection invisible. Do not manually overwrite the managed section; make durable project notes in the designated memory or technical files so a later refresh can reproduce the same context.
Run the documented plan–todo–implement loop
Plan: establish scope before editing
In agent mode, ask for plan after selecting the card. The extension’s documented workflow treats planning as a separate stage. The agent should inspect the repository, identify affected files and dependencies, and state assumptions or risks before implementation. Use this stage to clarify acceptance criteria while changes are still cheap to reject.
Rank #2
- 5-in-1 USB-C Hub: Experience comprehensive connectivity featuring a Power Delivery input, two USB-A 2.0 ports, a USB-A 3.0 port, and an HDMI port. (Note: The USB-C power delivery input port is only for connecting an external wall charger to power your laptop and cannot power peripheral devices.)
- 90W Pass-Through Charging: Achieve optimal charging with 90W pass-through power to your laptop, supported by a total input of 100W, with the hub reserving 10W for operational efficiency. (Note: Wall charger not included.)
- Quick Data Transfers: Accelerate your productivity with rapid data transfers using a high-speed 5Gbps USB 3.0 port and two 480Mbps USB 2.0 ports.
- 4K HDMI Display: Enhance your visual experience with a hub capable of delivering 4K resolution at 30Hz in both mirror and extend modes. Please note that this hub is compatible with MacBook (macOS 12 and newer), Windows 10 and 11, ChromeOS, and laptops equipped with DP Alt Mode and Power Delivery. Note: This device is not compatible with Linux.
- What You Get: Anker USB-C Hub (5-in-1, 4K HDMI), welcome guide, 18-month warranty, and our friendly customer service.
Todo: turn the plan into checkable work
Use todo to break the selected task into concrete steps. A useful todo list names the file or subsystem, the intended change, and the verification method. Keep unrelated improvements out of this list; if they deserve attention, create separate Kanban cards so priority remains visible on the board.
Implement: let the agent execute the approved scope
Use implement when the plan and todo list match the card’s purpose. GitHub’s agent-mode documentation describes the agent as determining which files to change, proposing code changes and terminal commands, and iterating to remediate issues until the original task is complete. You can send follow-up prompts while it works to narrow scope, correct an assumption, or change the order of remaining steps.
Implementation does not automatically mean the card is complete. Review the diff, run the project’s tests and checks, and decide whether the board status should advance. Keep the card’s title and context aligned with the actual change; if the work expanded, split the remaining scope into another task instead of silently rewriting the original objective.
How an agent updates a card and its context
AgentKanban provides several update channels. They serve different purposes, so use the right one for each kind of information.
| Channel | What it stores | When it is useful |
|---|---|---|
Managed AGENTS.md section |
The currently selected task and the context the agent should load | Every new session that works on the active card |
.agentkanban/MEMORY.md |
Durable project or task notes that should survive a session | Decisions, constraints, terminology, and discoveries |
.agentkanban/TECHNICAL.md |
Technical details relevant to implementation | Architecture notes, interfaces, commands, and environment facts |
| MCP tool calls | Board reads and updates exposed to a supported agent | When the agent needs to retrieve or change board data directly |
| Optional turn capture | Prompts and agent responses associated with the task | Auditing or preserving conversation history |
Managed context is refreshed by selection
Selecting a different card with @kanban /task updates the managed context immediately. This prevents a new session from inheriting yesterday’s task by accident, but it also means you should confirm the active task before issuing implementation instructions.
MCP enables direct board operations
The extension writes MCP configuration for supported agents. With that configuration available, an agent can read board information and issue supported updates through MCP tools. The exact tool names and exposed fields depend on the extension and harness version, so inspect the available tools in the agent session rather than guessing a command. MCP does not create an automatic priority policy; it only gives the agent a controlled way to perform board operations you authorize.
Rank #3
- Sleek 7-in-1 USB-C Hub: Features an HDMI port, two USB-A 3.0 ports, and a USB-C data port, each providing 5Gbps transfer speeds. It also includes a USB-C PD input port for charging up to 100W and dual SD and TF card slots, all in a compact design.
- Flawless 4K@60Hz Video with HDMI: Delivers exceptional clarity and smoothness with its 4K@60Hz HDMI port, making it ideal for high-definition presentations and entertainment. (Note: Only the HDMI port supports video projection; the USB-C port is for data transfer only.)
- Double Up on Efficiency: The two USB-A 3.0 ports and a USB-C port support a fast 5Gbps data rate, significantly boosting your transfer speeds and improving productivity.
- Fast and Reliable 85W Charging: Offers high-capacity, speedy charging for laptops up to 85W, so you spend less time tethered to an outlet and more time being productive.
- What You Get: Anker USB-C Hub (7-in-1), welcome guide, 18-month warranty, and our friendly customer service.
Turn capture is opt-in
Conversation capture is not enabled by default. When you enable it, prompts and agent responses can be recorded back to the task. Do this only when the project’s privacy and retention rules allow it, particularly if chats contain credentials, customer data, or proprietary source excerpts. Enabling capture later does not imply that earlier turns were stored.
Restore task context in a new agent session
A new chat starts with a clean conversational history, but the task context can be reconstructed from the workspace.
- Open the same connected workspace.
- Run
@kanban /task <task name>to make the intended card active again. - Read the managed
AGENTS.mdsection and the relevant memory or technical notes before asking for code changes. - If the agent’s responses still reflect stale or incomplete information, run
@kanban /refresh. - Ask the agent to restate the current objective and remaining todo items before continuing.
/refresh re-injects the selected task context; it does not replace a deliberate review of what changed in the repository. If the files and the card disagree, resolve that mismatch first rather than asking the agent to infer which source is authoritative.
Prioritize work without pretending the agent has an automatic ranking system
Choose the active task deliberately
AgentKanban’s documented prioritization model is explicit and user-directed. Select the card that should consume the next agent session, then give that session a bounded plan and todo list. The board’s order and status communicate your decision to collaborators; they are not calculated from an advertised score.
Use board order and status as the shared signal
Arrange cards with your board’s normal ordering controls and keep statuses accurate. Put blocked work where collaborators can see the dependency, move ready work into the lane your team uses for execution, and leave completed work for review until verification is finished. The extension connects the selected card to VS Code, but your board conventions determine what “next” means.
Manage multiple sessions in the Agents window
VS Code’s Agents window is designed for assigning tasks, managing several sessions, following progress, and reviewing results. Start parallel sessions only when their file and dependency boundaries are clear. If two agents can edit the same module or migration, sequence them instead of relying on a last-write-wins outcome. Assign the highest-value or most time-sensitive card to the session with the clearest acceptance criteria.
Rank #4
- Dual Converters, Infinite Potential：Includes 2× USB C male to USB A female adapters and 2× USB A male to USB C female adapters. Perfect for a wide range of uses—tablets with Bluetooth keyboards, expand USB ports on macbook, and more. Two different converters for all your daily needs
- Next-Level 10Gbps & 3A Charging: No more slow 480Mbps, this usb to usb c adapter has a transfer speed of up to 10Gbps, allowing you to do more transferring in less time. This usb adapter fits both USB A and USB C charger, supporting up to 3A fast charging
- Upgraded Exquisite Craftsmanship: With an aluminum alloy housing and metal connector, the usbc to usb adapter is extremely durable and sturdy. Rigorously tested to withstand more than 10,000 times of plugging and unplugging, ensuring long-lasting performance
- Broad Compatible: The usb c to usb adapter widely supports all USB C/ USB A devices like laptops, tablets, cellphones, car chargers, and phone chargers. Such as compatible with MacBook Pro/Air 2023/2022, Thunderbolt 4/3 Devices,Apple MagSafe Watch 9/8/7/SE/Ultra, iPad Pro 2022/2021, Samsung Galaxy S23/S20/S10, and iPhone 17/16/15 Pro. Plug and play
- Please Note: To reach 10Gbps speed, keep the cable under 3.3 ft. For USB A Male to USB C adapters, try flipping the USB C connector. USB C Male to USB A adapters support bidirectional 10Gbps transfer within 3.3 ft
Do not infer unsupported automation
The documented sources do not describe automatic priority scores, due-date optimization, workload balancing, or an agent that independently reorders cards. If you need those policies, encode them in your team’s board process and ask the agent to report against that process; do not assume the extension is calculating them.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsUse worktrees for large or risky cards
Run @kanban /worktree when a task could destabilize the main checkout or needs an isolated branch. The command creates a task branch and separate working directory, writes task-specific AGENTS.md context, and opens that worktree in VS Code.
- Select the card you want isolated.
- Invoke
@kanban /worktree. - Verify that VS Code opened the new working directory and that its
AGENTS.mddescribes the intended task. - Run the plan–todo–implement loop inside that worktree.
- Review tests and the Git diff, then merge the branch through your normal Git workflow.
- Update the board only after the branch’s state matches the card’s completion criteria.
Worktrees reduce accidental edits to the main workspace, but they do not remove the need for review. A branch can still contain an incorrect implementation, and a card can still be marked complete too early.
AgentKanban and native VS Code planning: what each contributes
These workflows solve different coordination problems. AgentKanban makes a board card durable across sessions; VS Code’s native Plan agent structures the implementation decision inside a session.
| Capability | AgentKanban workflow | Native VS Code Plan agent |
|---|---|---|
| Task creation surface | @kanban /new <title> creates a board card. |
Starts from an agent request and produces a project plan; it is not documented as creating a Kanban card. |
| Context between sessions | Managed AGENTS.md, local Markdown memory, and task selection restore context. |
Plan artifacts and the workspace help retain implementation decisions, but board-card selection is outside the Plan agent’s documented role. |
| Status and priority | User selects the active task and manages board order and status. | User chooses whether to approve, implement, or reject the plan; no Kanban ranking is supplied. |
| Board integration | MCP configuration lets supported agents read and update board data. | Plans and implementation actions stay within VS Code’s agent workflow unless another integration is added. |
| Isolation | @kanban /worktree creates a task branch and separate directory. |
Uses the workspace and source-control options you configure; the Plan agent itself is not documented as creating Kanban worktrees. |
| Approval controls | Your plan, todo list, code review, and Git merge provide checkpoints. | Offers Implement Plan, Approve Plan Only, Implement with Autopilot, or Reject actions. |
A practical combination is to select the Kanban card first, use the native Plan agent to research and propose the implementation, then return to the card’s documented todo and implement stages. The board answers “which work matters now?” while the Plan agent answers “what is a safe way to do it?”
Free tools Windows power users keep installed
One-click scans. No signup required.
End-to-end example
Create and select
Start with @kanban /new Add server-side image type validation, then run @kanban /task Add server-side image type validation. Check that AGENTS.md now identifies this card.
Best Value
- 5-in-1 Connectivity: Equipped with a 4K HDMI port, a 5 Gbps USB-C data port, two 5 Gbps USB-A ports, and a USB C 100W PD-IN port. Note: The USB C 100W PD-IN port supports only charging and does not support data transfer devices such as headphones or speakers.
- Powerful Pass-Through Charging: Supports up to 85W pass-through charging so you can power up your laptop while you use the hub. Note: Pass-through charging requires a charger (not included). Note: To achieve full power for iPad, we recommend using a 45W wall charger.
- Transfer Files in Seconds: Move files to and from your laptop at speeds of up to 5 Gbps via the USB-C and USB-A data ports. Note: The USB C 5Gbps Data port does not support video output.
- HD Display: Connect to the HDMI port to stream or mirror content to an external monitor in resolutions of up to 4K@30Hz. Note: The USB-C ports do not support video output.
- What You Get: Anker 332 USB-C Hub (5-in-1), welcome guide, our worry-free 18-month warranty, and friendly customer service.
Plan and decompose
Ask for plan. After reviewing the proposed files and risks, use todo to require: identify the upload boundary, add MIME and signature checks, add rejection tests, and document the supported formats. If the agent discovers an unrelated storage migration, create a separate card instead of adding it to this one.
Implement and verify
Use implement, review each diff, and run the project’s existing test commands. Record an architectural decision or a format constraint in .agentkanban/MEMORY.md or .agentkanban/TECHNICAL.md when it will matter to the next session.
Continue later
In a new session, select the same task and run @kanban /refresh if the agent lacks the latest context. Ask it to inspect the current diff and remaining todo items before making another change. Mark the card complete only after the tests and review satisfy the acceptance criteria.
Troubleshooting common failures
The agent is working on the wrong card
Run @kanban /task <task name> again and inspect the managed AGENTS.md section. If multiple cards have similar names, use a more distinctive title and verify the board selection before continuing.
The session forgot earlier decisions
Run @kanban /refresh, then check .agentkanban/MEMORY.md and .agentkanban/TECHNICAL.md. Conversation history is not guaranteed unless optional turn capture was enabled, so durable decisions belong in the Markdown files.
The agent cannot update the board
Confirm that the workspace is connected to the board and that the agent harness supports the MCP configuration written by AgentKanban. Without MCP support, provide instructions in chat and make the board change through its normal interface rather than assuming the agent can perform it.
Two sessions are producing conflicting edits
Stop one session, compare the diffs, and assign each card a non-overlapping file or dependency boundary. For high-risk work, recreate the task in a separate worktree with @kanban /worktree and merge only the reviewed branch.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
The card says complete but the code is not ready
Separate board status from conversational optimism. Re-run tests, inspect the diff, and move the card back to the appropriate status until the stated acceptance criteria are met. The extension does not verify correctness merely because an agent finished a response.
Quick Recap
Operational checklist
- Connect the correct VS Code workspace to the intended board.
- Create cards with
@kanban /new <title>rather than burying unrelated work in chat. - Select one active card with
@kanban /task <task name>before planning. - Review the managed
AGENTS.mdcontext and relevant local Markdown notes. - Follow the
plan,todo, andimplementstages. - Use MCP only with a supported agent harness and review every board update it proposes.
- Enable turn capture only when privacy and retention requirements permit it.
- Use
@kanban /refreshwhen a new session has stale context. - Use
@kanban /worktreefor broad or risky changes that should not touch the main checkout. - Prioritize explicitly through card selection, board order, and session assignment; do not expect automatic ranking.
- Review tests, diffs, and branch state before marking a card complete.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
