Qwen Code Setup: Free AI Coding with Extensions, PDCA Workflows, and Context Engineering

TL;DR: Here’s my Qwen Code stack:

Start with whatever solves your biggest pain point:

• Want structured dev workflow → bkit
• Outdated docs → Context7
• Context bloat → context-mode
• Domain-specific quality → shared skills

Why Qwen Code?

I already have an opencode setup that works well. But opencode requires a paid model provider. Qwen Code gives me a fully open-source (Apache 2.0) AI coding agent with 2,000 free requests per day via Qwen OAuth — no credit card, no subscription.

The selling points:

The 0.8% gap behind Claude on SWE-bench at $0 vs $240/year makes it a no-brainer for everyday tasks.

The Architecture

My Qwen Code setup follows the same three principles as my opencode config:

1. Prompt Engineering — bkit’s 21 agents and 35 skills enforce structured workflows
2. RAG — Context7 + Tavily provide current information
3. Context Engineering — context-mode protects the context window

The Core — bkit PDCA Workflow Engine

Without structure, AI assistants freestyle. bkit solves this by enforcing the PDCA (Plan-Do-Check-Act) methodology — a 10-event hook system that intercepts the full Qwen Code lifecycle.

What Is bkit?

bkit is an extension originally built for Gemini CLI that auto-converts to Qwen Code format. It provides three layers of Context Engineering:

The 10-Event Hook System

bkit intercepts Qwen Code’s full lifecycle:

The key insight: phase-based tool filtering. During the Plan phase, bkit restricts tools to read-only. During Do, all tools unlock. This prevents the AI from making changes before it understands the codebase.

The 21 Agents

bkit provides specialized agents that auto-activate based on task type and project level:

Project level auto-detection:

The 35 Skills

The skills cover the full development lifecycle:

Configuration

bkit installs as a Qwen Code extension with these settings:

1
{
2
  "contextFileName": ["GEMINI.md"],
3
  "settings": [
4
    {
5
      "name": "Output Style",
6
      "description": "Response formatting style (bkit-learning, bkit-pdca-guide, bkit-enterprise, bkit-pdca-enterprise)",
7
      "envVar": "BKIT_OUTPUT_STYLE"
8
    },
9
    {
10
      "name": "Project Level",
11
      "description": "Override auto-detected project level (Starter, Dynamic, Enterprise)",
12
      "envVar": "BKIT_PROJECT_LEVEL"
13
    }
14
  ]
15
}

Key bkit config highlights:

• PDCA status file: .pdca-status.json — tracks phase transitions automatically
• Auto-iterate: Enabled by default, up to 5 iterations per task
• Model routing: Pro models for plan/design/do, flash models for check/act/report
• Team orchestration: Supports up to 10 agents with 5 patterns (leader, council, swarm, pipeline, watchdog)
• Agent memory: Persistent across sessions, scoped per-project or per-user

Installation:

1
qwen extensions install <bkit-repo-url>
2
qwen extensions settings bkit

Layer 1 — Current Information (Context7)

The Problem

Models trained months ago hallucinate confidently about APIs that have since changed.

The Solution — Context7 Extension

Context7 provides an MCP server that queries live library documentation on demand.

Installation:

1
qwen extensions install context7
2
qwen extensions settings context7  # Set CONTEXT7_API_KEY

Extension manifest:

1
{
2
  "name": "context7",
3
  "mcpServers": {
4
    "context7": {
5
      "command": "npx",
6
      "args": ["-y", "@upstash/context7-mcp", "--api-key", "${CONTEXT7_API_KEY}"]
7
    }
8
  }
9
}

Included skills (3):

Workflow: Resolve library ID first (ctx7 library), then query docs (ctx7 docs). If you already know the ID, skip straight to querying. Supports version-specific docs.

Layer 2 — Context Protection (context-mode)

The Problem

Raw tool outputs flood the context window. A single Playwright snapshot is 56 KB. The session dies before any real work happens.

The Solution — context-mode

context-mode intercepts tool outputs and routes them through an isolated subprocess. Only condensed summaries enter context. Full data stays in a searchable FTS5 database.

AGENTS.md Enforcement

This is identical to my opencode setup — the same rules file works across both tools:

Tool hierarchy (same as opencode):

1. GATHER: ctx_batch_execute — primary tool, one call replaces 30+ individual calls
2. FOLLOW-UP: ctx_search — query indexed content with natural language
3. PROCESSING: ctx_execute / ctx_execute_file — sandboxed subprocess execution
4. WEB: ctx_fetch_and_index — fetch, chunk, index, query without touching context
5. INDEX: ctx_index — store content in FTS5 for later retrieval

Output constraints:

• Keep responses under 500 words
• Write artifacts to files, not inline text
• Use descriptive source labels for indexed content

Layer 3 — Domain Skills (26 Shared Skills)

These live in ~/.agents/skills/ and are shared between Qwen Code and opencode:

Framework Skills (10)

Go Skills (2)

Research Skills (8)

Quality & Other Skills (6)

Why shared? Both Qwen Code and opencode support the ~/.agents/skills/ directory. One skill file, two AI assistants, zero duplication.

Global Configuration

settings.json

1
{
2
  "security": {
3
    "auth": {
4
      "selectedType": "qwen-oauth"
5
    }
6
  },
7
  "model": {
8
    "name": "coder-model"
9
  },
10
  "permissions": {
11
    "allow": [
12
      "Bash(npm init *)",
13
      "Bash(git add *)",
14
      "Bash(git commit *)",
15
      "Bash(git push)"
16
    ]
17
  }
18
}

Output Language

Enforced via ~/.qwen/output-language.md:

• Default: English (mandatory, not preference)
• Exception: Explicit language request switches for remainder of conversation
• Technical artifacts (code, CLI commands, file paths) preserved verbatim

File Structure

1
~/.qwen/
2
├── AGENTS.md                          # Context-mode routing rules
3
├── settings.json                      # Auth, model, permissions
4
├── output-language.md                 # Language enforcement
5
├── extensions/
6
│   ├── bkit/                          # PDCA workflow engine
7
│   │   ├── qwen-extension.json
8
│   │   ├── bkit.config.json           # 248-line centralized config
9
│   │   ├── agents/                    # 21 specialized agents
10
│   │   ├── skills/                    # 35 PDCA/phase skills
11
│   │   ├── hooks/                     # 10-event hook system
12
│   │   ├── mcp/                       # Spawn-agent MCP server
13
│   │   └── policies/                  # Level-based policies
14
│   └── context7/                      # Live documentation
15
│       ├── qwen-extension.json
16
│       └── skills/                    # 3 doc-fetching skills
17
├── projects/                          # Per-project chat history
18
└── todos/                             # Persistent task tracking

What Makes Qwen Code Different

Beyond what I’ve configured, Qwen Code has features I haven’t fully explored yet:

Approval Modes

Four modes, cycled with Shift+Tab:

Sandbox Execution

• macOS: Seatbelt profiles (6 built-in: permissive/restrictive x open/closed/proxied)
• Linux: Docker/Podman with custom Dockerfiles
• Custom profiles: .qwen/sandbox-macos-*.sb or .qwen/sandbox.Dockerfile

LSP Integration

Experimental (--experimental-lsp): go-to-definition, find references, call hierarchy, hover, diagnostics, code actions.

Headless Mode

1
# Non-interactive for scripts/CI
2
qwen -p "Run tests and fix failures" --approval-mode yolo
3

4
# Pipe input
5
cat requirements.txt | qwen -p "Create a project from these requirements"
6

7
# Stream JSON for tool integration
8
qwen -p "Analyze" --output stream-json > session.jsonl

Multi-Provider Support

Use any model from one CLI:

1
{
2
  "modelProviders": {
3
    "openai": [
4
      { "id": "qwen3.5-plus", "baseUrl": "https://...", "envKey": "BAILIAN_CODING_PLAN_API_KEY" },
5
      { "id": "gpt-4o", "envKey": "OPENAI_API_KEY" }
6
    ],
7
    "anthropic": [
8
      { "id": "claude-sonnet-4-20250514", "envKey": "ANTHROPIC_API_KEY" }
9
    ],
10
    "gemini": [
11
      { "id": "gemini-2.5-pro" }
12
    ]
13
  }
14
}

Switch models mid-session with /model.

Subagents

Configurable parallel task delegation:

1
{
2
  "subagents": {
3
    "maxConcurrent": 4,
4
    "maxNestingDepth": 2,
5
    "defaultModel": "gemini-2.5-flash",
6
    "inheritApprovalMode": true
7
  }
8
}

Session Checkpointing

Enable via general.checkpointing.enabled — restores token counts, request counts, and model usage on resume.

What I Could Install Next

How It Compares to My Opencode Setup

Both setups share the same principles. The difference is execution:

When I use which: Qwen Code for structured feature work where PDCA adds value. Opencode for quick tasks, refactoring with GitNexus safety, and vision-dependent debugging.

Closing

The beauty of this setup is that most of it is portable. The 26 shared skills in ~/.agents/skills/ work in both Qwen Code and opencode. The context-mode AGENTS.md is identical. Only the workflow engine differs — bkit for Qwen Code, Superpowers for opencode.

If you’re looking for a free, powerful AI coding setup, start with Qwen Code + Context7 + context-mode. Add bkit when you need structured workflows. Add domain skills as you encounter specific frameworks.

The three principles hold regardless of tool choice: prompt engineering, RAG, and context engineering. Everything else is implementation detail.

References

This article was written by opencode (GLM-5-Turbo | Z.AI Coding Plan).

Related Articles

My Opencode Setup: Guardrails, Intelligence, and Skill-Driven AI Workflows

Mar 28, 2026

bkit: Structured PDCA Workflows and Context Engineering for Gemini CLI

Mar 31, 2026

Beads: A Memory Upgrade for Your Coding Agent

Mar 31, 2026