Cisco is giving some engineers unlimited AI tokens, with legacy code rewriting as one of the primary use cases.
This is not about asking AI to build a few more features. What changes is the cost structure of repetitive work such as migrating old systems, adding tests, and translating framework interfaces.
Free tokens do not make engineering outcomes free. Missing context, undocumented business rules, and blind spots in the test suite remain. More importantly, AI can submit large batches of changes quickly, which means mistakes can also be replicated in bulk.
Cisco President Jeetu Patel linked the arrangement to the development of Gen Z engineers and the changing nature of entry-level roles. According to Fortune, the focus is on rewriting legacy code rather than simply producing more code.
The story also reached the Hacker News front page, where it received 101 points and 112 comments. What engineers care about is clearly not the word “unlimited.” Once unlimited usage enters the production process, the harder questions are who owns review, validation, and accountability when something goes wrong.
Original report: Fortune
What Unlimited Tokens Actually Solve
A token is the unit of computation a model uses to process text. Input consumes tokens, and so does output.
Generating a new function might require only a few thousand tokens. Migrating a module that has been running for years to a new interface, then updating its callers, configuration, tests, and documentation, can cost far more. Legacy code often contains years of accumulated patches, which makes direct deletion and replacement equally risky.
Cisco’s arrangement is well suited to this kind of work:
- Mapping old framework interfaces to a new API.
- Updating dependencies and call sites in bulk.
- Adding initial test cases to modules that lack coverage.
- Breaking up repetitive logic that spans thousands of lines.
- Translating configurations and scripts between runtime environments.
The benefit is not measured in lines of code. Suppose migrating a module originally takes 12 person-days, with 7 days spent tracing call relationships, moving code, and adjusting formatting. AI could compress much of that mechanical work.
The remaining 5 days cannot simply disappear:
- Determine whether the old behavior should actually be preserved.
- Find edge cases that were never documented.
- Decide whether the tests validate requirements or merely reproduce the existing implementation.
- Decide which compatibility risks are acceptable.
Unlimited tokens primarily address the cost of the first part. They do not automatically provide business knowledge or assume responsibility for rollbacks.
There is another easy-to-miss cost: the more code AI changes, the more expensive human review becomes.
If AI generates 500 lines, reviewers may only need to check a few critical branches, and the trade-off could work. If it generates a 50,000-line diff, review becomes the bottleneck even if generation takes no time at all. Reviewers must rebuild their understanding of the system; otherwise, they can do little more than trust a green test run.
Tokens Do Not Equal Unlimited Engineering Capacity
The hardest part of legacy code is often not what it does, but why it was written that way.
A payment API is a typical example. An extra retry may have been added after a production incident. A field may be nullable because of a customer’s special contract. Error handling may bypass the standard path because a downstream service once failed.
AI can detect clues in code and comments, but it cannot recover organizational decisions that were lost years ago.
The risk can be divided into four layers.
Missing Context
A repository may contain READMEs, design documents, issues, chat logs, and incident reports. They are usually incomplete and rarely follow a consistent format.
Even if a model can read a large amount of context in one pass, that does not mean all relevant knowledge exists in the repository. Unlimited tokens do not conjure missing information.
Undocumented Business Rules
Many rules were never written into the code.
“Order status can only move through these seven states” may exist only in a product manager’s head. “European customer refunds require manual review” may appear only in a document shared by the operations team.
During a rewrite, AI may produce code that is logically complete, correctly typed, and fully covered by tests while quietly changing the meaning of the business.
Insufficient Test Coverage
The absence of tests around an old module does not mean it has no behavior.
AI-generated tests may simply mirror the current implementation. If the same model then modifies the implementation, the result can be a self-consistent but incorrect test suite. This is test and implementation drift together.
A safer approach is to derive independent assertions from historical tickets, production samples, and edge cases before asking the model to change the implementation. The source of the tests should not be identical to the source of the implementation.
Errors Reproduced at Scale
When a human developer submits one faulty condition, its impact is often confined to a single module. An AI Agent can copy the same mistake across dozens of call sites, including into generated tests.
The more tokens are available, the more important small-batch changes become. Pull requests should be split according to dependencies so that each batch can be independently validated and rolled back.
The sensible use of an unlimited allowance is not to launch one Agent that runs for several days and then review everything at once. It is to have the Agent continuously submit small diffs: migrate one interface at a time, add one group of edge-case tests, or update one caller at a time.
Entry-Level Engineering Tasks Are Changing
Jeetu Patel discussed unlimited AI tokens alongside the development of Gen Z engineers and changes to entry-level roles.
The issue is not whether younger developers can still learn to code. Even when AI generates most boilerplate, understanding a program still requires people to write, run, debug, and modify it themselves.
What changes is the nature of a new engineer’s first assignment.
New hires may once have started by implementing CRUD interfaces and writing unit tests. Today, those may be precisely the tasks best delegated to an LLM. Instead, new hires may inherit modules modified by AI and need to answer harder questions:
- Which requirement does this change address?
- Which old behaviors were preserved, and which were changed?
- Why do the tests prove that the change is correct?
- How will the code degrade if a dependent service fails?
- If this logic breaks, who can diagnose it, and how quickly?
This kind of review requires new engineers to understand the system, its constraints, and its failure modes. It is closer to the work of a senior engineer than writing boilerplate from a specification, but it should not replace fundamental training.
One warning sign is a team that stops assigning small, complete implementation tasks to new hires because AI can generate the code. The new developer’s job becomes clicking “Accept” and running tests. They can submit a diff without being able to explain the system’s behavior independently.
A better development model lets AI handle repetitive work while preserving two kinds of practice:
- Hand-write a small module first to develop debugging instincts and code-reading skills.
- Then review a complete AI-generated change and compare it with your own approach.
The first builds execution skills; the second develops judgment. Neither replaces the other.
Measuring Whether an AI Rewrite Is Worth It
“How many lines of code were generated?” is a poor primary metric. It rewards unnecessary code and obscures review costs.
Create a migration dashboard for each module and record at least the following five measures.
| Metric | How to calculate | Primary question |
|---|---|---|
| Migration time | Human hours from the start of work through acceptance | Did AI actually save time? |
| Defect escape rate | Defects found after deployment / all defects | Was validation sufficient? |
| Regression test pass rate | Successful CI runs / total CI runs | Are the changes stable? |
| Manual review cost | Minutes spent reviewing code and logs | Does faster generation offset review time? |
| Rollback rate and time | Number of rollbacks and time required to diagnose them | Is the risk controlled? |
A baseline should also be preserved.
Choose similar modules and record the results of both manual migrations and AI-assisted migrations. Without that comparison, a team may only perceive that “things feel faster” without knowing whether migration time was saved or the cost was deferred to testing and deployment.
A simple script can record CI results. It does not replace a full evaluation framework, but it can standardize the data format used for manual migrations:
import json
from pathlib import Path
results = []
for path in Path("ci-results").glob("*.json"):
data = json.loads(path.read_text())
results.append({
"module": data["module"],
"passed": bool(data["passed"]),
"review_minutes": int(data["review_minutes"]),
"rollback": bool(data.get("rollback", False)),
})
passed = sum(item["passed"] for item in results)
pass_rate = passed / len(results) if results else 0.0
review_minutes = sum(item["review_minutes"] for item in results)
rollback_rate = (
sum(item["rollback"] for item in results) / len(results)
if results else 0.0
)
summary = {
"runs": len(results),
"regression_pass_rate": round(pass_rate, 4),
"review_minutes": review_minutes,
"rollback_rate": round(rollback_rate, 4),
}
Path("migration-summary.json").write_text(
json.dumps(summary, ensure_ascii=False, indent=2) + "\n"
)
print(json.dumps(summary, ensure_ascii=False, indent=2))Run it with:
python summarize_migrations.pyThe project must first export its CI data as ci-results/*.json. The fields remain intentionally simple so the metrics can start running and then be filled in over time.
Beyond volume, teams should examine the types of errors. The most common problems in an AI rewrite may not be syntax errors. They may include:
- Silently swallowing exceptions that were previously raised.
- Changing timeout or retry policies.
- Losing transaction boundaries.
- Turning asynchronous calls into synchronous ones.
- Using default values for parameters that previously had to be supplied explicitly.
Final test coverage alone will not catch these issues. Teams need to compare the new and old implementations through behavioral difference analysis, then monitor production metrics.
Editorial Perspective
Cisco’s unlimited tokens are more of an organizational process experiment than a mature purchasing standard. As model costs fall, the bottleneck in AI-assisted programming does shift from “Can it generate?” to “Can it validate?” But unlimited allowances can also create the illusion that more calls automatically mean faster transformation.
The more meaningful distinction is what is different this time. AI programming has mainly helped engineers write new code; Cisco’s experiment reaches directly into migration, testing, and job design. Code review moves from a supporting activity to the central production step, and the model does not take responsibility for engineering decisions.
Teams will likely produce less boilerplate, but they will not need less understanding of system behavior. Entry-level engineers may submit their first change faster, but diagnosing failures independently still takes time to develop. If Cisco can reduce migration costs, defect escape rates, and the time required to develop new engineers at the same time, the model will be worth copying. For now, the debate in the 112 Hacker News comments makes the distinction clear: unlimited tokens address cost, not accountability.