Infosys partners with Anthropic to bring Claude Code and agentic skills to the Topaz platform. A deep dive into enterprise-scale legacy refactors and AI agents.
What the Infosys–Anthropic partnership puts on the table
Infosys is bringing Anthropic’s Claude Code and agentic skills into the Topaz platform so enterprise teams can use coding agents inside existing delivery workflows rather than as isolated experiments. That matters less as a product announcement and more as a distribution and governance choice: the model and tooling sit where programs already manage requirements, code, environments, and release gates.
Claude Code is useful when the work is multi-file, multi-step, and tightly coupled to repositories—not when the need is a single chat answer. Agentic skills extend that pattern by encoding repeatable procedures (investigate, plan, edit, test, document) so agents follow a defined path instead of improvising every time. On Topaz, those capabilities become platform features that can be scoped by project, role, and policy.
Why enterprise legacy refactors are a natural fit
Large modernization programs fail less often from a lack of code generators and more from incomplete understanding of systems that grew over years of patches, vendor packages, and tribal knowledge. A coding agent helps when it can read real modules, map call paths, surface hidden dependencies, and propose incremental changes that compile and pass existing checks—not when it rewrites an entire stack in one pass.
Practical agent-assisted refactor work tends to look like this:
- Inventory: locate services, shared libraries, batch jobs, and integration points before changing behavior.
- Boundary definition: pick a module or API surface small enough to review and roll back.
- Safe edits: prefer mechanical transforms and interface-preserving changes over big-bang rewrites.
- Verification: run unit, integration, and regression suites the team already trusts; treat agent output as a draft until those pass.
- Knowledge capture: keep the agent’s findings (dependency notes, risk lists, migration steps) in the repo so the next change is cheaper.
Operating model: agents as junior engineers with guardrails
At enterprise scale, the bottleneck is review and risk, not raw token throughput. Teams should assign agents clear tasks with acceptance criteria, require human approval on architecture-affecting diffs, and keep secrets and production credentials out of agent context. Logging prompts, tool calls, and resulting patches makes audits and post-mortems possible when something goes wrong.
Topaz-style platform integration helps here if it centralizes model access, repository permissions, environment isolation, and policy checks. Without that, every squad invents its own agent setup—and compliance, cost control, and quality standards fragment. With it, Claude Code becomes a shared capability: same tooling, different project scopes, consistent gates before merge.
How to run a pilot without overcommitting
Start with a bounded legacy slice: one service, one batch pipeline, or one set of brittle interfaces that already have tests. Measure cycle time from “ticket opened” to “merged change,” defect rate on agent-touched files, and reviewer hours per change—not abstract productivity scores. Expand only when the team can explain failures and when agent proposals routinely need only light edits.
Keep humans accountable for design decisions, data handling, and production readiness. Use agents for exploration, scaffolding, test generation, and mechanical migration steps. That split—agentic skills for execution, engineers for judgment—is how Claude Code on an enterprise platform like Topaz becomes durable infrastructure rather than a short-lived demo.