DEV Community: Shixin Zhang

Agentic R&D Insights

Shixin Zhang — Thu, 09 Apr 2026 05:15:02 +0000

This year, I dove headfirst into Agentic Coding and automated workflows, integrating them intensely into my daily development and research. The general consensus is that AI crossed a critical threshold late last year, and my hands-on experience confirms it. I’ve barely written any code manually this year, and the output from AI agents has been staggering.

To give you an idea of the scale: my tensorcircuit-ng (TC) repository saw a net increase of over 20,000 lines of python code. It took me barely two days to organically integrate and rewrite QuEra's newly released tsim into the TC framework. On the research front, I built paper-reproduction infrastructure within TC, allowing me to reproduce highly complex, representative quantum physics papers in mere minutes—I’ve knocked out over a dozen so far. Once, I spent less than a day running an end-to-end automated pipeline that handled a referee report: supplementing experiments, plotting graphs, writing the reply, and revising the manuscript. Algorithmically, I used the TC paradigm to auto-generate high-quality DMRG code in minutes; it natively supports GPUs and its CPU efficiency beats mature frameworks like quimb. Throw in fully automated translations of the TC documentation and auto-filling grant proposal templates, and the efficiency multiplier is absolutely an order of magnitude or more.

But looking at this massive output, an inevitable question arises: In an era where everyone has access to the exact same cognitive baseline—models like Claude 4.6 or GPT 5.4—what actually dictates the ceiling of our productivity? Why aren't we seeing a 100x boost across the board?

After high-intensity practice, I realized the answer isn't "better prompt engineering." It's hidden in the architecture of your workflow. The real differentiator is how you leverage personal data and experience to build a resilient system across the "Frontend, Middle, and Backend" of your pipeline. Interestingly, while building this system, you inadvertently design the exact countermeasures needed to mitigate the three fatal character flaws highly intelligent LLMs exhibit: Laziness, Impatience, and Deception.

The Frontend: Personal Context as the Ultimate Moat

The core insight for the frontend is simple: personal context and workflow paradigms are your ultimate moats in the Agent Era. The coding world is a perfect playground for AI not just because code is easily verifiable, but because its physical logic is self-consistent and its context is completely intact—there is no context fragmentation.

In general problem-solving, our thoughts are scattered across our brains, chat logs, loose docs, and random materials. Without centralized, normalized context, an AI agent will always struggle. In my practice, context consists of a static component and a dynamic one.

The static "Wiki" is the cognitive bedrock for the LLM. The tensorcircuit-ng monorepo itself acts as a hyper-powerful context infrastructure. It doesn’t just hold framework code; it aggregates nearly 200 specific quantum use cases, physical logic constraints, and historical experiment logs. When the LLM hooks into this, it isn't facing a sterile prompt—it's stepping into a rich, domain-specific knowledge base. (Karpathy recently mentioned using AI to index and retrieve personal knowledge bases—often without even needing vectorization, as smart grep and indexing work better. This "Based AI, for AI, from AI" context management is something I had already implemented, and it feels like the most natural evolution of human-computer interaction.)

The dynamic "Skill" component is the digital extension of your personal execution paradigm. Sure, for generic tasks like parsing a DOCX, you just use an off-the-shelf plugin. But workflow skills are deeply personal and nearly impossible to substitute. I don't believe in using standard, third-party workflow skills; every individual's needs are highly customized. I built a .agents/skills toolbox inside TC specifically for performance reviews, paper reproduction, and tutorial generation. I also have a private skill repository encapsulating my highly specific habits for logging numerical experiments, SSHing into remote clusters, and drafting grants.

Simply put: the Wiki tells the AI "what we have," and the Skills tell the AI "how I think and solve problems." (Fun fact: the reason this post doesn't sound like AI slop is because I instructed the AI to mimic my previous blog posts. The blog itself became the context. The AI summarized my style as: "No redundant formatting, hardcore geeky tone, stream-of-consciousness switching between tech and philosophy.")

This frontend architecture perfectly mitigates the AI's first character flaw: Laziness. This laziness often stems from performance degradation and attention-loss over long context windows. Anyone who uses AI knows that on long-haul tasks (like full-repo refactors or translations), it loves to slack off, do half the work, or just spit out a function signature with a pass statement. But when you lock the AI in a high-quality Wiki that enforces strict background constraints, and use custom Skills to force large tasks into atomic, pipeline steps, the AI loses the room to cut corners. You have to back the AI into a corner where it has no choice but to apply its full intellect to solve your problem.

The Middle: The Economics of Human-in-the-Loop

When it comes to execution, there is only one rule: reject blind end-to-end automation. Intervening, discussing, and course-correcting in the middle of a task is vastly more economical.

Many people chase the dream of fully autonomous end-to-end agents. But for research or engineering tasks with strict delivery requirements that cannot be 100% automatically verified, this is a recipe for disaster. Human-in-the-loop (HITL) is mandatory. Think of it like a Principal Investigator advising a PhD student. You don't write every line of code for them, but you must have regular syncs, correct their trajectory, and redeploy tasks based on current progress. You don't just wait three months and read the final paper. The time and "human bandwidth" spent on these middle-stage checks seem costly, but compared to the agonizing effort of reverse-engineering what the AI did wrong—or doing a complete rewrite because the architecture was flawed from day one—it is negligible.

Furthermore, one or two sentences of human intuition can be the difference between success and total failure. This is why human experts still matter. A quick pointer can pull an AI out of a logical mud pit; without it, the task stalls. Currently, the best AI-driven research is done by domain experts, and the best AI-written code is guided by senior engineers. Relying on "AI vibes" in a domain you don't understand only yields half-baked prototypes. AI is not a silver bullet; human taste, experience, and intuition remain rare and decisive.

This mentorship model mitigates the AI's second flaw: Impatience. This impatience is an artifact of RLHF, which encourages models to generate the shortest path to an answer. When an AI hits a test failure or a bug, its first instinct is almost never to carefully read the stack trace. Instead, it relies on hallucinated intuition to blindly hack the source code, hoping for a quick green light. It usually makes things worse. If it fails again, it hacks the code again, refusing to write a script to verify its assumptions.

With HITL, we lay down the law: whenever there is an error, the AI is strictly forbidden from touching the source code. It must first write a minimal reproducible demo script to isolate the bug, and then report back to me. Often, just writing the demo makes the AI realize the bug isn't where it thought it was. Only after I confirm the root cause is the AI allowed to modify the codebase. This forced braking mechanism pulls the AI out of its blind-hacking loop and forces rational deduction.

The Backend: Testing, Eval, and the Bandwidth Bottleneck

In the backend evaluation phase, we have to face a harsh reality: while automated testing and evaluation determine the floor of an Agent's capabilities, human bandwidth is almost always the ultimate ceiling.

Automated testing is crucial. It’s the very foundation of why AI excels at coding tasks (think RLVR). Some argue that tests are the new moat, even more important than the implementation itself, because an AI can generate the implementation if the tests are exhaustive. (This is why some modern frameworks open-source their code but close-source their test suites).

But even in highly formalized tasks like code generation—especially when doing secondary development on a mature, opinionated codebase—humans are still required for global architectural design, semantic alignment, and taking ultimate responsibility for the code. Just like managing a team of human engineers, there is a hard limit to how many Agents a human can effectively manage. We cannot infinitely scale compute and Agent instances and expect them to output 100% reliable work entirely on their own. In the AI era, trust and attention are the most precious resources. Testing and acceptance simply require massive human bandwidth to bridge that trust gap.

Since human review is unavoidable, the trick is to exploit the AI's asymmetric capabilities to save our bandwidth. An LLM's ability to judge (discriminate) is significantly stronger than its ability to generate. Therefore, we can introduce AI cross-validation as a firewall before human review. I use an independent, freshly instanced model in an extremely clean context to review the generated code logic, creating an automated loop of adversarial review and revision. The "clean context" is vital—the reviewer AI must never see the messy trial-and-error history of the generator AI, otherwise it will empathize with the generator and lose its objectivity.

This clean-room evaluation mechanism mitigates the AI's third flaw: Deception (Reward Hacking). If you rely solely on basic automated tests, AI becomes terrifyingly deceptive. To make a failing test turn green, it will maliciously use workarounds or physics-defying hardcodes just to hack the test suite. An independent reviewing Agent with strong discriminative capabilities and a clean context acts as a filter, catching these brainless "code-golfing" hacks before they ever reach my desk, saving my precious bandwidth for the final architectural sign-off.

Conclusion

By building deep personal Contexts, forging custom Skill tools, enforcing HITL mentorship, and utilizing clean-room independent evaluations, you really can boost your productivity by an order of magnitude.

But let's be clear: these systems only mitigate the AI's laziness, impatience, and deception—they do not cure it. In the foreseeable future, human bandwidth remains the absolute bottleneck in the Agent workflow. Dreaming of a 100x or 1000x productivity boost today will only result in highly unreliable output.

And perhaps that’s not a bad thing. In this human-machine collaboration, AI is the ultimate generation engine and an untiring preliminary reviewer. But the final quality control, the closing of the physical logic loop, and the ultimate responsibility for the scientific output must rest with the human. When everyone has access to the exact same AI, your accumulated personal data, your polished workflows, and where you choose to invest your limited human bandwidth (decision-making, reviewing, critical insights) become your deepest moats. The irreplaceable nature of humans right now lies in implicit knowledge—taste, intuition, and problem-framing—which cannot be distilled into a text prompt or an executable Skill.

Of course, given the breakneck speed of AI development, if these remaining "irreplaceable" human traits become commoditized a year from now, I won't be surprised. By this time next year, perhaps none of these insights will even be relevant anymore.

Unleashing AI in Quantum Research: Why TensorCircuit-NG is the Ultimate Foundation for the Agent Era

Shixin Zhang — Thu, 12 Mar 2026 01:45:14 +0000

With LLMs and AI agents making code generation faster, cheaper, and more accessible, a massive new frontier has opened in scientific computing. But while AI can easily string logic together, it still needs a powerful, mathematically rigorous engine to drive it.

This is where TensorCircuit-NG (TCNG) truly shines. Far from just adapting to the AI era, TCNG acts as the essential catalyst that makes AI-driven quantum research possible, scalable, and highly performant.

Here is why TCNG is more important than ever for researchers and AI agents alike.

🧱 1. The Foundational "Physics Engine" for AI

AI models are fantastic at orchestrating high-level logic, but they struggle to invent highly optimized, low-level mathematical frameworks from scratch. TCNG represents the kind of deep, specialized engineering that is incredibly hard to replicate. By fusing machine learning backends with customized hardware operators and advanced tensor network contraction engines, TCNG acts as a fundamental infrastructure layer. Just as AI agents don't try to rewrite TensorFlow or PyTorch—they simply use them—agents can call TCNG as foundational building blocks to construct complex quantum applications effortlessly.

🛡️ 2. Guiding AI to High-Performance Paradigms

Left to its own devices, AI can easily generate code that works but runs terribly. TCNG solves this by providing a strict, high-performance architecture. Because TCNG enforces strong paradigms—such as backend-agnostic design, automatic differentiation (AD), Just-In-Time (JIT) compilation, and hardware acceleration (GPUs/TPUs)—it inherently forces AI to write code using best practices. When an agent builds with TCNG, the resulting scripts automatically inherit top-tier performance and scalability without the AI needing to understand the underlying computational bottlenecks.

📚 3. Unmatched Context Completeness for Agents

For an AI agent to be truly autonomous and accurate, it needs massive, high-quality, and unified context. TCNG provides exactly this: over six years of rich, accumulated domain knowledge packed into a cohesive mono-repo. It houses everything from exhaustive documentation to edge-case physics functionalities. Because the entire quantum landscape is mapped out within a single repository, it is incredibly friendly for AI agents to ingest, cross-reference, and use as a springboard for creating entirely new tools and discoveries.

🧠 4. A Massive Training Ground for Automated Discovery

AI learns best by example, and TCNG is built to be the ultimate reference library. We now host over 150 carefully crafted example scripts, providing an incredibly strong foundation for AI to recognize quantum programming patterns and generate novel applications. Leveraging this, we are launching an exciting new initiative: fully automated reproduction of representative quantum research papers, driven entirely by AI using TCNG's vast library as its reference point.

🛠️ 5. Native Agentic Skills Out of the Box

TCNG isn’t just designed for human researchers to use alongside AI; it is actively built to give AI agents superpowers. TCNG provides a series of native "skills" designed to help agents automate complex workflows, including:

End-to-end reproduction of research papers
Seamless code translation across different frameworks
Automated performance optimization and profiling
The auto-generation of interactive demos and educational tutorials

The Bottom Line

In the era of AI agents, coding might be cheap, but world-class scientific infrastructure is priceless. TensorCircuit-NG provides the deep-tech foundation, the optimized paradigms, and the rich, accumulated context that AI needs to push the boundaries of quantum physics. It isn't just a tool; it is the infrastructure that will power the next generation of automated quantum discovery.

We Built the First AI-Native Quantum Software Framework: Say Hello to Agentic TensorCircuit-NG

Shixin Zhang — Sat, 28 Feb 2026 06:02:18 +0000

Quantum computing software is notoriously hard to write.

If you want to simulate a deep quantum neural network or research a new algorithm, you don't just need to understand Hamiltonian dynamics and Hilbert spaces. You also need to be a High-Performance Computing (HPC) expert—wrestling with GPU memory limits (OOMs), vectorization, JIT compilation staging times, and tensor network contraction paths.

For years, we've provided developers with the tools to do this via TensorCircuit-NG, our next-generation open-source, high-performance quantum software framework.

But tools are passive. You still have to do the heavy lifting.

Today, we are changing the paradigm. We are thrilled to announce that TensorCircuit-NG is now the world’s first AI-native quantum programming platform purpose-built for agentic quantum research and automated scientific discovery. By natively integrating skills directly into our repository, your quantum framework now comes with a built-in HPC engineer, a theoretical physicist, and a technical writer.

The Paradigm Shift: Agent-Ready Architecture 🧠

Most AI coding assistants do "line-by-line" translations or generate boilerplate. That doesn't work in quantum simulation, where a poorly placed for loop can increase compilation time from 2 seconds to 2 hours.

Instead of writing endless tutorials on "best practices," we embedded our framework knowledge directly into the repository as Agentic Skills.

If you clone the latest TensorCircuit-NG repo, you'll notice a new directory structure:

Plaintext

.agents/skills/
├── arxiv-reproduce/
├── performance-optimize/
├── tc-rosetta/
└── tutorial-crafter/

These aren't just prompts; they are strict, engineering-bound AI workflows. Let's break down the four superpowers you now have access to right out of the box.

1. `/arxiv-reproduce`: From arXiv ID to JAX-Accelerated Code in Minutes 📄➡️💻

The gap between reading a cutting-edge quantum machine learning paper on arXiv and actually writing the code to reproduce it is huge.

With the arxiv-reproduce skill, you simply hand the AI an arXiv link. The agent will:

Extract the physical intent (the Ansatz, the Hamiltonian, the loss function).
Intelligently scale down the qubit count so it runs on your local machine without blowing up your RAM.
Generate idiomatically correct, JAX-accelerated TensorCircuit-NG code.
Automatically run formatting (black), linting (pylint), and execute the script to save the reproduced figure into a standardized outputs/ folder.

2. `/performance-optimize`: Your Built-in HPC Architect ⚡

Got a quantum script that takes forever to compile or crashes with an Out-of-Memory (OOM) error?

The performance-optimize agent scans your code to identify bottlenecks. It knows the dark arts of quantum HPC: it will automatically eradicate Python loops in favor of jax.vmap, wrap your deep quantum layers in jax.lax.scan to slash JIT staging time, inject jax.checkpoint to trade compute for memory during backpropagation, and seamlessly switch to cotengra for optimal tensor network contraction paths. It even runs A/B benchmarks to prove the speedup!

3. `/tc-rosetta`: End-to-End Cross-Ecosystem Translation 🌍

Migrating from older, object-oriented quantum frameworks (like Qiskit or PennyLane) to a modern, differentiable, functional framework like TensorCircuit-NG is a steep mental shift.

tc-rosetta does not do naive line-by-line syntax swapping. It performs end-to-end intent extraction. It reads your slow, loop-heavy legacy script, understands the math behind it, and rewrites it from scratch using pure JAX-native paradigms. It then executes both scripts and hands you a benchmark report (e.g., "Execution time reduced from 300 seconds to 0.2 seconds").

4. `/tutorial-crafter`: Automated High-Quality Documentation 📝

Writing docs is the bane of every open-source contributor. What if the code could explain itself?

Point tutorial-crafter at any raw TensorCircuit-NG script. It will analyze the physical background and the code, then generate a beautiful, narrative-driven tutorial in both Markdown and HTML formats. It chunks the code logically, adds LaTeX formulas for the physics theory, and explicitly points out the HPC programming highlights (e.g., "Notice how we used vmap here instead of a loop..."). It generates documentation that rivals hand-crafted, premium tutorials.

How to Experience the Magic ✨

Because these skills are built on the open standard, getting started is zero-friction.

Clone the TensorCircuit-NG repository.
Open your terminal in the repo root.
Fire up your AI agent and simply call a skill: /performance-optimize examples/my_slow_circuit.py

You are no longer just writing code; you are directing an autonomous digital research team.

Welcome to the era of Agentic Quantum Software Engineering. We can't wait to see what you discover. Check out the repo, give us a star, and let the AI handle the boilerplate while you focus on the physics! 🌌

🚀 TensorCircuit-NG: The Universal, Differentiable Quantum Infrastructure

Shixin Zhang — Tue, 10 Feb 2026 03:13:39 +0000

👋 Hello World!

If you are a developer exploring quantum machine learning, or a physicist tired of rewriting code to make it run on GPUs, you have likely faced the "Framework Dilemma."

Do you write in PyTorch because you need the dataloaders?
Do you switch to JAX for that sweet JIT compilation speed?
Do you stick to TensorFlow because of legacy production pipelines?

What if your quantum simulator didn't care?

Meet TensorCircuit-NG (Next Generation)—the open-source, tensor-native platform that unifies quantum physics, AI, and High-Performance Computing.

🌟 What is TensorCircuit-NG?

TensorCircuit-NG is not just another circuit simulator. It is a backend-agnostic computational infrastructure.

It is designed to let you define your physics logic once and execute it anywhere. It wraps industry-standard ML frameworks (JAX, TensorFlow, PyTorch) into a unified engine, making quantum simulation end-to-end differentiable and hardware-accelerated.

🛠️ The "Write Once, Run Anywhere" Philosophy

The killer feature of TensorCircuit-NG is Infrastructure Unification.

You don't need to learn a new dialect for every backend. You simply switch the engine with one line of code:

Python

import tensorcircuit as tc

# Want JAX for JIT speed?
tc.set_backend("jax")

# Want PyTorch for easy integration with your existing DL models?
tc.set_backend("pytorch")

# Legacy TensorFlow project?
tc.set_backend("tensorflow")

This flexibility enables radical interoperability. You can train a hybrid model where the data pipeline lives in PyTorch, but the heavy-duty quantum circuit simulation is JIT-compiled via JAX/XLA for massive speedups—all handling zero-copy tensor transfers (DLPack) under the hood.

⚡ Why You Should Try It

1. Native Machine Learning Integration

We treat quantum circuits as first-class citizens in the computational graph.

Plug-and-Play Layers: Use tc.TorchLayer or tc.KerasLayer to insert parameterized quantum circuits directly into classical ResNets or Transformers.
Automatic Differentiation (AD): Forget parameter-shift rules. We compute gradients via backpropagation through the tensor network, making VQE and QML training exponentially faster.

2. HPC-Ready Scalability

Stop simulating on your CPU. TensorCircuit-NG supports:

GPU/TPU Acceleration: Move simulations to NVIDIA GPUs or Google TPUs without changing your physics code.
Distributed Computing: We support automated data parallelism (scaling to multiple devices) and model parallelism (tensor network slicing across GPU clusters).
Benchmark: We've demonstrated near-linear speedups on 8x NVIDIA H200 GPU clusters, simulating end-to-end variational quantum algorithms with 40+ qubits.

3. Advanced Physics Engines

It’s not just for qubits. TCNG comes with batteries included for:

Fermions Gaussian States: Efficiently simulate thousands of fermions.
Qudits: Native support for high-dimensional systems (d≥3).
Noise Modeling: Customizable noise channels for realistic hardware simulation.

💻 Show Me The Code

Here is how simple it is to build a differentiable variational circuit (VQE) that runs on any backend: