Compilers let programmers work at a higher level. Engineers could describe operations in a programming language instead of writing every machine instruction. AI agents are extending that shift. We can describe a problem, define the expected behavior, and delegate much of the implementation, testing, and revision. That gives engineers more time to decide what a system should do and solve its design and functional problems. At QuEra, we have been putting this approach to work and learning where it helps, and where it needs tighter controls.

The compiler comparison has limits. A compiler follows defined language rules. An AI agent interprets requirements, which may be incomplete or ambiguous. It can inspect code, suggest an approach, make changes, run tests, and respond to review comments. It can also misunderstand the problem and produce code that looks convincing. Passing tests does not necessarily mean the requirements were right or the implementation solves the intended problem. Engineers still have to make those judgments.

We are not trying to remove software engineers or make their expertise obsolete. We are changing how they spend their time and which qualifications we emphasize. Domain expertise helps engineers recognize constraints an agent might miss. Critical thinking helps them question assumptions and assess the result. Good writing is increasingly important because requirements, interface contracts, and acceptance criteria need to be precise. Software fundamentals remain essential. Engineers must understand, debug, and maintain the code they deliver, regardless of who—or what—wrote it.

At QuEra, Engineering built Quantopus to coordinate agents working on software. Its first project was the Admin Usage Recorder, which records who used a quantum computer and how, providing information for accounting and billing. Worker agents implement tasks and add tests. Reviewers check changes against requirements. A planner turns findings into follow-up work, and a nightly testing agent probes the running service. Engineers retain control over design decisions, protected tests, and what reaches the main codebase. An agent cannot change the definition of success simply because its implementation fails a test.

We also have results from a separate effort using AI under an engineer’s direction. Across user groups and task profiles, the review recorded 101 completed tasks and 111 merged pull requests across 19 repositories. One engineer used Cursor and Claude Code while also working on other projects. The merged changes added about 11,200 lines of production code and 25,400 lines of tests, with 223 tests in the two new services. These were interactive sessions, not unattended Quantopus runs, so we should keep the two approaches distinct.

Task profiles went from an empty repository to a merged service in six days and was running on testbed and a real QPU in seven days. The initial PR reported 35 passing tests, including database and API integration tests. User groups took 88 days to reach all four clusters, with the engineer also working on other projects. The engineer merged all 111 PRs across both efforts, 54 also received peer review. The work included 56 plan checklists and 82 AI review records. We know how long delivery took, but we do not have a comparable project to measure the speedup.

AI costs were approximately $3,900 across both projects. The report estimates the same scope at 9.5–13.5 engineer-months, or $144,000–$205,000 in salary. That points to significant potential savings, but the comparison is incomplete. The $3,900 excludes the engineer’s time and infrastructure, prices Claude usage at API rates rather than the actual subscription cost, and misses earlier Claude usage. The effort estimate also has roughly ±50% uncertainty. These results are encouraging, but they do not establish a precise savings figure or productivity multiplier. The test results are reported from the projects, we have not independently rerun them.

We have also learned from expensive failures. Quantopus’s repository documents a reviewer run that repeatedly reread the project, consumed roughly 500 million cached-input tokens, and cost about $1,000. We needed execution windows, gaps between cycles, and limits on how much content a run could read. Asking the agent to use fewer resources was not enough.

Cloud resources make it easy to expand agent capacity, but that capacity is not unlimited or free. Agents can spend time rereading code, repeating revisions, or raising findings that add little value. We need limits on spending, runtime, concurrency, and repeated failures. We also need to count the engineer’s time spent specifying, reviewing, and correcting the work. More generated code is useful only if it produces accepted, maintainable changes at a reasonable total cost.

Agents need access to our engineering knowledge as well as our code. Designs, interface contracts, operating constraints, and earlier decisions are spread across documents, tickets, and discussions. Internal retrieval-augmented generation, or RAG, can help engineers and authorized agents find that information, with references they can check.

That also makes access permissions more important. Information that was technically available to everyone but difficult to find becomes much easier to discover and summarize. Connecting a retrieval platform to an identity provider establishes who is accessing it; it does not fix overly broad permissions in the source systems. We need clear content owners, approved sources, exclusions, and tests showing that restricted information stays restricted.

The same applies to policies. RAG can help an agent find our engineering standards and usage rules, but it cannot enforce them by itself. Restrictions on repositories, protected interfaces, spending, and approvals must be enforced through credentials, development systems, and the agent launcher. We should be able to see what an agent accessed, changed, tested, and submitted for approval.

The proposed expansion across QPU access management, QuetzalOS, and other repositories should start with small, defined tasks. Each repository needs its own tools, tests, and approval points. Changes affecting hardware timing or physical behavior still need appropriate validation. We should measure whether agents reduce implementation effort without creating more review and rework.

Quantum computing requires software across controls, calibration, compilation, cloud access, and customer operations. Our engineers need more time for the design and functional problems that require their expertise. AI agents can help by taking on more of the detailed implementation. Our early results support continuing that work, with clear requirements, independent checks, and engineers responsible for the outcome.