You can connect Qwen Code to 1PC as a remote MCP server, then read saved product scope before starting a coding task. Qwen Code supplies the assistant and repository tools; 1PC supplies product knowledge, accepted decisions, progress and selected workflow guidance.

This guide covers the Qwen Code CLI. It follows official documentation checked on October 4, 2026 and gives you a connection check to perform; it does not claim a completed live 1PC test or a connector inside Qwen's chat website.

Prepare the client and product

Install the CLI using the Qwen Code quickstart, start qwen and complete model authentication. Run /auth if you need to change that setup. Model access and usage charges follow your chosen provider account. Record qwen --version when checking your connection.

You need a 1PC User and access to the intended Product. Every User has the available skills and private workspace methods; accepted private MCP calls consume prepaid credit. See the MCP overview for connection requirements.

Configure remote HTTP

Create and verify your 1PC account, then create a personal access token in MCP connections. It grants full User access, expires after 90 days and can be revoked. Use it through the environment-based header below and keep it in secret storage. The account connection guide covers both connection routes. Configure and check Qwen Code separately; use the existing account for saved work.

In Bash or Zsh, enter your token at a hidden prompt, then export it in the shell that will start Qwen Code:

printf '1PC token: '
read -r -s ONEPC_MCP_TOKEN
printf '\n'
export ONEPC_MCP_TOKEN

Merge this object into your user settings at ~/.qwen/settings.json, preserving other settings. The Qwen Code settings reference documents string environment interpolation and QWEN.md instructions. Project settings can override user settings, so check for an existing onepc entry if the result differs.

{
  "mcpServers": {
    "onepc": {
      "httpUrl": "https://use1pc.com/mcp",
      "headers": {
        "Authorization": "Bearer ${ONEPC_MCP_TOKEN}"
      }
    }
  }
}

Start or restart qwen from that shell and open /mcp. Wait for onepc discovery before asking it to read product state. The Qwen Code MCP guide documents httpUrl for Streamable HTTP and bearer headers. Use this transport; 1PC does not provide a local subprocess or legacy SSE endpoint.

This example uses a personal token. Both products also document OAuth, but Qwen Code's documented default callback uses http://localhost:7777/oauth/callback, which 1PC does not accept. An OAuth setup needs a compatible registered callback and resource handling verified against the Qwen developer reference and 1PC authentication contract. Do not assume default OAuth compatibility from tool discovery.

Enter Product Owner explicitly

An MCP connection exposes tools. It does not install the native 1PC Product Owner plugin skill in Qwen Code. Start with this read-only entry request, replacing the fictional product name with yours:

Use onepc for this product workflow. First call
get_skill_instructions with skill_id "product-owner", phase "entry".
Follow its current requirements and applicable checks. Read workspace
context, paginate accessible products and the skill catalog, and resolve
Follow-up Board. Keep product_id explicit once selected.

Read its relevant saved context, accepted decisions and progress. Explain
the current state and relevant inputs before choosing guidance. If the product is ambiguous, ask me to choose.
Do not create a product, save information or change repository files yet.

Look at the actual tool activity and returned files. A plausible summary is not evidence that saved state was read. Product Owner selects an available skill from the catalog, loads get_skill_instructions with its skill_id and phase work, and loads relevant product context for that skill. The backend supplies selected Markdown and separate requirements; the host carries out the requested work.

For repeated use, put the entry reminder in a project QWEN.md and inspect loaded instructions in /memory. Keep only the reusable instruction there. Fetch changing product facts and requirements through 1PC again in each fresh session.

Review scope before coding

Suppose Follow-up Board helps freelance designers notice unanswered proposals. You are considering a reminder feature. Before editing code, use the saved MVP scope to make the next change reviewable:

Using the saved scope and current accepted decisions, prepare a small
implementation brief for proposal reminders. Identify the customer
outcome, in-scope behavior, exclusions and acceptance checks. Mark each
claim as supported by saved context, a proposal or an unknown.

If my local repository is available, inspect only the relevant files to
check current behavior. Cite those files separately from saved product
evidence. Ask about material conflicts. Do not implement or save yet.

The MVP planning guide owns the scope method. An original candidate checklist for this fictional feature could be:

  • A designer can choose a reminder date for one unanswered proposal.
  • A reminder becomes visible when due and can be dismissed.
  • The first version does not send an email to the prospect.

These are proposals to review against your actual product, not existing requirements or proof of implementation. Accept the brief before authorizing repository changes. Qwen Code's local files and tests can supply implementation evidence when available; 1PC does not automatically watch or sync them.

When accepted scope affects messaging, Product Owner can surface related work. Use the shared feature launch marketing plan to connect it to supportable landing-page claims and an acquisition experiment. A related suggestion does not launch another workflow or publish content.

Save and resume a reviewed update

When you approve information for persistence, choose the explicit Product, Feature, Version or Task scope, department, document role and stable key. Prepare and self-review the update, preserve valid content and commit its exact revision. Check access for the selected domain guidance and website tools separately.

Save the approved scope update for this selected product using the
agreed scope, department, reference role and stable key.
Preserve valid existing information and use the revision you read.
Verify the save receipt, then read the file back and report its actual
path and revision. Keep proposed behavior distinct from accepted scope
and tested implementation.

Prepare and self-review each scoped update, commit with its exact revision and current Task claim where required, then verify the saved receipt. An uncertain write response needs a destination read before a retry; a revision conflict needs refreshed content and recovery guidance.

Open a fresh Qwen Code session with the same connection, repeat Product Owner entry and provide the actual path returned by the save:

Enter Product Owner through onepc again. For the selected product, read
the saved scope update at this path and its current revision. Explain
the accepted behavior, outstanding questions and next authorized step.
Do not rerun the review, save anything or start implementation.

This checks whether reviewed information persisted. The cross-tool context guide explains how saved knowledge carries across compatible clients. Unsaved conversation details and unreported repository activity do not.

Resolve setup gaps before repeating work

  • No connection: check that your installed version supports the shown settings, the endpoint is correct and discovery has finished.
  • Unauthorized read: verify the Qwen Code process received ONEPC_MCP_TOKEN and replace an expired or revoked token.
  • Tools visible but no saved context: request Product Owner entry and inspect the actual read calls.
  • Unavailable guidance: inspect catalog availability and your 1PC plan. Connecting does not grant paid access.
  • Different context in a new session: check the selected product and saved path. A local instruction file is not the saved product record.

Keep host tool confirmation enabled while checking the connection. Revoke the token in 1PC when removing access; deleting local configuration alone does not revoke it. Use the MCP reference for detailed authentication and save rules.

Continue connected product work

Once read/save/read-back works, expand one task at a time. A repeated review method can become a published private product skill in 1PC Settings → Skills. Product Owner can discover and load it with the appropriate access; authoring and publication happen on use1pc.

The useful connection is between your next repository task and the product decisions already reviewed. Keep scope, actual implementation checks and proposed marketing work distinguishable so the next session can continue from evidence.

Finish your Qwen Code connection with the MCP reference.

Check authentication, tool availability and write requirements before using your saved product context for a larger task.

Open the 1PC MCP reference ↗