If you only use an AI coding tool to:
Change a button.
Write a function.
Fix an error.
Many tools are already:
Very user-friendly.
The real challenge arises when:
Projects get bigger.
Today, you’re on:
Website A
asking AI to remember:
"Never alter production directly."
Tomorrow, you’re on:
App B
telling it:
"All APIs in this project follow a different rule set."
Meanwhile, you run:
Three Agents.
One fixes bugs.
One runs tests.
One reviews code.
After a few hours, the real problem may no longer be:
Can AI write code?
But:
Which project does it currently remember?
What is each Agent doing?
Is this branch behind the remote?
Is the file AI plans to edit actually inside this workspace?
Qwen Code’s latest 0.23.0 update
starts clearly addressing:
these kinds of issues.
What is Qwen Code?
Qwen Code is an:
open-source AI coding Agent.
The most basic way to use it is directly in the:
terminal.
But it’s long since no longer just a:
command-line chat box.
Current official features include:
SubAgents.
Agent Teams.
Dynamic Workflows.
Auto-Memory.
Auto-Skills.
MCP.
Plan Mode.
Sandbox.
Git Worktrees.
Computer Use.
IDE Plugins.
Desktop App.
SDK.
And even:
Daemon Mode.
Simply put, it aims to:
not just:
"help you fill in code,"
but also to:
integrate AI deeply into the software project workflow.
The top feature for developers in 0.23.0: Scoped Memory
After extensive AI coding,
memory becomes a big problem.
Imagine you maintain simultaneously:
A client website.
Your own SaaS.
Internal tools at your company.
Three projects, each with:
Different frameworks.
Different folder structures.
Different coding conventions.
Different deployment rules.
Different no-touch areas.
If AI mixes all memories into one,
memory could actually:
cause you trouble.
For example, Project A has the rule
"All database migrations must first be tested in staging."
This is good practice.
But Project B:
has no staging environment.
It uses a:
completely different deployment flow.
If the Agent doesn’t know:
which memory belongs to which workspace,
it might mistakenly apply:
the correct rule
to the wrong project.
This is called:
Context Leakage.
Not a data leak,
but:
AI applying habits and rules from one workspace incorrectly to another.
Qwen Code 0.23.0 introduces Scoped Workspace Memory
According to the release notes,
memory tasks can now specify:
Project Target
or:
User Target.
Also, during Remember/Forget actions,
strict permissions enforce:
filesystem permission boundaries between different stores.
Simply put,
you can start separating:
memories specific to this project
from:
your own long-term personal preferences.
This matters more than:
"AI remembers more."
What belongs in User Memory?
For example,
your personal preferences such as:
Always plan before writing code.
Run tests on major changes first.
Provide concise answers.
Use a specific format for commit messages.
These usually apply across all projects,
so they’re better suited at the:
User level.
What belongs in Project Memory?
For example,
In this Laravel project:
Never modify production directly.
In this app:
Always use a specific test command.
In that repository:
Certain folders are off-limits.
For a given client:
API naming conventions.
These are best kept:
project-specific,
not traveling with you across repositories.
The real improvement isn’t more "AI memory"
It’s:
clear boundaries around AI memory.
This is crucial when agents work long-term.
The more memory agents hold,
if scopes are unclear,
mistakes can have a bigger impact.
Second key feature: Multiple Agents can run concurrently in the background
Previously, using a coding agent often meant:
waiting in line.
Ask the AI to:
fix the login bug.
Wait.
Then:
run tests.
Wait again.
Then:
review code.
Now, Qwen Code supports:
SubAgents.
Agent Teams.
Dynamic Workflows.
And in 0.23.0, it adds:
Concurrent Named Task Control.
Meaning:
different named tasks
can work simultaneously.
You can switch to:
another context,
while background tasks continue running.
For example, if you have three tasks:
Task A:
Find the checkout bug.
Task B:
Review yesterday’s pull requests.
Task C:
Organize test failures.
You don’t have to:
finish one before starting the next.
Different agents can:
handle each task separately.
You can view:
Task A’s results,
while B and C run in the background.
This starts to feel like:
managing
a small AI team,
rather than just chatting with a single chatbot.
But more agents isn’t always better
If you run:
ten agents,
each editing the same code,
the same branch,
and same file,
they’ll likely:
conflict with one another.
Multiple agents work best for:
divisible tasks.
For example,
one looks for bugs,
one reads logs,
one reviews,
one writes tests.
Not:
four agents
editing the same production code section.
0.23.0 also lets sessions send named messages to each other
The update adds:
Session/Agent
named:
Send Message
List Agents
This may seem small,
but means multi-agent work evolves from:
"I have many windows open at once"
to:
Agents can coordinate.
For example, the test agent finds:
a bug traced to an API response.
It can share:
this result
with the agent fixing the API.
Long-running work requires:
this kind of handoff.
Third practical improvement: Workflow can pause, resume, and retry
As AI agent tasks get longer,
the biggest worry is:
only
start,
and
stop completely
are options.
Qwen Code 0.23.0 pushes workflow run control forward.
Daemon exposes controls like:
Inspect.
Cancel.
Pause.
Resume.
Retry.
Delete.
Meaning:
a long process running halfway
doesn’t have to:
restart from zero.
For example, an agent reviewing a large codebase is running
You suddenly see:
the specs just updated.
Previously you could only:
stop, then restart.
Now, workflow architecture lets you:
pause,
check,
and if needed:
resume,
or retry a failed step.
This is much closer to:
what real work systems
should offer.
Because real AI agents won’t always succeed on the first try
If an agent works for:
20 seconds and fails,
retrying is no big deal.
But if it’s:
been running 40 minutes,
read many files,
completed the first seven steps,
then fails on:
step eight due to API timeout,
you don’t want:
to start all over.
Pause, resume, retry
may seem ordinary,
but for long-running agents,
they’re essential.
Fourth improvement: Each scheduled run creates a new session
Qwen Code 0.23.0 also adds:
Per-run Scheduled Task Sessions.
This means:
the same scheduled task
can create a new child conversation
each time it runs,
instead of piling all run logs into
a single long conversation.
Why is this useful?
For example, if every morning you run a code health check,
Monday has one session,
Tuesday a new one,
Wednesday another,
each with its
own execution context,
results,
and timestamp.
Looking up what happened on Tuesday
doesn’t require scrolling through a 3-month-long conversation.
This also means:
better agent maintainability.
Fifth handy feature: Git state visible before commit
For many AI coding tools,
the riskiest moment isn’t AI:
writing bad code,
but you not knowing:
which branch you’re on,
if your local repo is behind remote,
or if you have uncommitted changes.
Then proceeding to:
update, commit, and push.
In 0.23.0, Qwen Code adds:
Git state hints next to branch picker,
showing if you’re:
up to date,
or behind origin/main.
Why is this small info so important?
Because now AI coding agents
help with Git operations,
the key question isn’t:
"Can it operate Git?"
but:
What Git state does it see?
If local is behind remote,
but you tell the agent to push directly,
then the real problem may be not the code,
but the version state.
Seeing state before update, commit, and push
helps you make informed decisions.
Sixth important safety fix: Out-of-workspace writes can’t be auto-approved
One of the greatest risks with agents is not:
making a single code mistake,
but:
acting outside the project workspace.
Imagine your project lives in a specific folder,
but the agent tries to write elsewhere.
This kind of action poses different risks.
Qwen Code’s recent permission fix mandates:
AUTO Mode cannot auto-approve writes outside the workspace.
If an out-of-workspace write occurs,
it must be:
manually approved.
Meaning:
human review required.
This rule matters more than “AI is smart”
Because a truly safe agent
is not:
one that never makes mistakes,
but rather:
halts when errors approach high-risk boundaries.
For example:
work within workspace;
stop if outside.
Such technical boundaries
are much more reliable than just relying on prompts that say "don’t edit randomly."
Qwen Code’s standout feature: not tied to Qwen Model alone
At first glance,
you might think from the name "Qwen Code,"
it only works with:
the Qwen model.
But the official support extends to:
Qwen API.
OpenAI API.
Anthropic API.
Gemini API.
Third-party providers.
And even:
local models,
like Ollama,
vLLM.
You can also switch:
models at runtime.
This positioning is very different from a single-model coding tool
It’s more like a:
agent framework + coding environment.
Today you might:
use a local model for simple tasks,
switch to another provider for complex reasoning,
and a more powerful model for specific coding tasks —
all without redoing your entire workflow because you changed the model.
This approach closely resembles what
AT&T is working on, as mentioned in today’s morning news.
Mature AI usage
is no longer:
"Which single model does our company use?"
but:
"Which model is best suited for this job?"
Qwen Code also provides an Agent Arena
The official release includes:
Agent Arena.
For the same task,
you can have:
different models
compete head-to-head.
That is,
you compare how each performs on your specific work.
This is interesting to developers because model comparisons
can finally be about:
Who truly performs better on my repository?
For example, with the same bug,
you can let:
Model A
analyze it once.
Model B
analyze it again.
See:
who finds the true root cause,
who makes smaller changes,
and who has more complete test coverage.
This is closer to what you really need
than "Model X scores 2 points higher on SWE benchmarks."
Qwen Code works beyond the terminal
Official support currently includes:
Terminal.
Headless Mode.
VS Code.
JetBrains.
Zed.
Desktop App.
Daemon.
SDK.
And integrations with:
Telegram.
DingTalk.
WeChat.
Feishu.
If you don’t like the terminal,
you’re not locked into it anymore.
Desktop app makes it more approachable
Many feel intimidated
by AI coding agents because the first step
is opening a terminal.
But Qwen Code now offers:
macOS,
Windows,
Linux
desktop apps.
This marks a shift from:
a pure CLI tool
towards:
a fuller coding workspace.
It’s still a:
developer tool,
not a no-code app builder like Canva.
People unfamiliar with:
repositories,
Git,
tests,
deployment,
still need basic concepts to use it.
Who is Qwen Code for?
First:
Those maintaining their own websites or apps.
Especially if you don’t just open a single-file project daily,
but have:
multiple repositories,
different clients,
and varying coding rules.
Project-scoped memory is meaningful here.
Second:
Small development teams.
With Agent Teams,
background tasks,
workflow control,
and Git state,
it addresses multi-person and multi-task environments.
Third:
Those who don’t want to be locked into a single model.
If you want to test:
Qwen,
Claude,
OpenAI,
Gemini,
local models,
and switch within the same workflow,
this suits you better.
Fourth:
Users wanting control over their AI coding infrastructure.
Qwen Code is open source,
supports local models,
daemon mode,
SDK,
making it more controllable than relying solely on cloud providers.
Who might not need Qwen Code?
If you just:
occasionally tweak some HTML,
build small sites for the first time,
never use Git, terminal, or repositories,
simpler tools might suit you better.
Examples include:
Replit,
visual app builders,
or using ChatGPT
to generate code snippets directly.
Qwen Code’s true value kicks in when:
projects grow longer,
tasks increase,
and multiple agents are involved.
Why this post isn’t just about a “free Claude Code alternative”
That would miss the point.
While Qwen Code has many:
feature similarities to Claude Code,
the real takeaway is:
AI coding agents are now solving problems
previously only human dev teams needed to handle, like:
memory scope,
task coordination,
workflow state,
Git state,
and permission boundaries.
These aren’t issues about:
"can a model write a function?"
AI coding is moving from code generation to managing work state
The first generation:
autocomplete —
you type the first part, AI fills in the rest.
Second generation:
chat —
you say "write this," AI provides code.
Third generation:
agents —
they read your repository,
find files,
edit code,
run tests.
Now moving to the next step:
agent systems
with multiple agents,
multiple sessions,
memory,
workflows,
permissions,
and model routing.
The real management challenge is:
the overall work state.
This mirrors general AI workstreams beyond coding
It’s not just coding.
When AI agents start:
reading emails,
organizing drives,
browsing,
and updating CRMs,
they face similar challenges:
Which client does this memory belong to?
Can multiple agents run at once?
What tasks failed?
Which steps to rerun?
Where does manual approval kick in?
So what’s happening with Qwen Code now
could well become the direction for all AI agents in the future.
If it’s your first time testing, don’t start with production
Start with:
a local project,
or a test repository,
preferably with Git,
and tests,
but without risking customer impact.
Start a real task like:
"Find out why this form’s validation fails on mobile. Analyze first, no edits yet."
Observe how it reads the project,
organizes context,
then moves on to planning,
and finally editing.
Second test: Start using memory
For example, add just three project rules:
This project always uses a specific framework.
Tests to run before edits.
Production deployment is off-limits to agents.
Don’t overwhelm it with dozens of rules at first.
See if it truly:
applies rules correctly in later sessions.
Third test: Try parallel agents
For example:
Agent A:
finds root cause.
Agent B:
finds relevant test coverage.
The two tasks can be independent.
Avoid having multiple agents editing the same file simultaneously
at first, to better understand
if multiple agents actually save time.
Final test: Model switching
Use the same bug,
same repo,
same acceptance criteria,
letting different models
handle it.
Compare:
change scope,
test results,
token or cost,
manual review time.
Don’t just compare:
who sounds more like an expert.
True coding agent value is:
who makes the work easier to approve and complete.
One key caveat: Memory isn’t necessarily truth
Even well-isolated project memory
may contain errors.
If you’ve told it:
"This project uses Node 22,"
and two months later you upgrade to Node 24,
but forget to update old memory,
the agent may keep:
working according to outdated rules.
Memory management
therefore needs:
regular review.
This is why there’s a Forget task in the update
Mature memory management means not just:
remembering,
but also:
forgetting.
When rules expire,
versions upgrade,
or project structures change,
you need to:
clear outdated memory.
Otherwise,
the AI agent becomes like an employee
with excellent memory but stuck on old SOPs.
For small teams, what I value most isn’t multiple agents
but:
clearly defined boundaries.
Multiple agents look cool, but in real production,
the priorities are:
Project A never accesses Project B’s memory.
Out-of-workspace writes don’t get auto-approved.
Git state is visible so people review first.
High-risk actions can be stopped.
These are the conditions
to turn AI coding
from a toy into
a serious work tool.
The four key directions in Qwen Code 0.23.0 can be summarized as:
Separate memory.
Project and user
don’t mix.
Separate work.
Different agents
can run concurrently.
Visible state.
Workflows, sessions, Git state
can be tracked.
Stop on boundary violation.
Out-of-workspace writes
cannot be auto-approved.
If your current coding workflow only involves "ask AI one question, get one code snippet,"
Qwen Code might feel:
too much.
But if you are already:
letting agents edit real repositories,
managing multiple projects,
wanting model switching,
and running background work,
then 0.23.0 is more worthwhile than
"model benchmark score improvements."
Because in real AI coding work,
the biggest challenge is never:
just whether AI can write code.
It’s:
whether it knows which project it’s on, what it’s doing, which parts it can touch, and whether the results can be reviewed and accepted safely.
This is:
where AI coding agents
start to mature.
Today, let’s improve a bit with AI.
Learn one AI skill daily.
Save a bit of time daily.
Enhance a bit of capability daily.
SasaDaily, growing with you.
