Guest: Arun Gupta
Company: JetBrains
Show: 2026 Predictions
Topic: AI Governance

The “move fast and break things” era of AI development is ending. In 2026, enterprises are prioritizing software quality over the speed with which code can be generated, and the shift from experimental AI tools to production-ready governance frameworks is here. Arun Gupta, Vice President of Developer Experience at JetBrains, shares four critical predictions that will define how developers and organizations navigate AI-assisted development this year—and the practical steps to prepare now.

The Four Predictions Shaping 2026

Arun’s first prediction centers on interoperability becoming not just interesting, but mandatory. While 2025 gave us foundational standards like Model Context Protocol (MCP), Agent-to-Agent (A2A), Agent-to-UI (A2UI), and Agent Communication Protocol (ACP), critical gaps remain. “How do you do agent memory, context formats, security, identity frameworks, development workflow integration patterns? All of those standards are going to emerge,” Arun explains. JetBrains worked on ACP to allow developers to bring any coding agent to their IDEs—an open platform approach that avoids vendor lock-in. “We don’t pick winners. We want everything to work,” he says.

The second prediction is the rise of spec-driven development (SDD), a methodology Arun believes will become mainstream in 2026. Organizations are realizing that iterative prompt-based development creates unmaintainable code bases without audit trails or scalability for team environments. SDD splits work into two distinct phases: thinking, where humans write clear specifications including architecture decisions and business logic, and doing, where agents create implementation plans and build accordingly. “This is not just a methodology. It becomes the only viable approach for regulated industries like finance, healthcare, and government that need clear accountability for code provenance,” Arun notes. JetBrains IDEs are positioned as the natural home for SDD, with semantic understanding ensuring agents have accurate context and refactoring tools bridging spec updates to implementation changes.

Third, Arun predicts that multi-agent development environments will arrive in 2026. Complex software development will require orchestration across specialized agents—one for implementation, one for testing, another for documentation, and one for security analysis. “IDEs are going to evolve from being just a code editor plus an AI copilot into a true agent-orchestration hub,” he explains. Developers will become conductors, directing multiple specialized agents while maintaining architectural vision and making critical judgment calls. Open standards like ACP will enable this without locking developers into a single vendor.

The fourth prediction addresses enterprise AI governance, which Arun sees moving from nice-to-have to compliance requirement. “The questions aren’t ‘does this work?’ but ‘can we audit this? Who’s liable if this fails?'” AI tools will face the same scrutiny as any enterprise software, requiring audits, policy enforcement, review integration, and accountability. Insurance companies will start requiring governance frameworks, and regulated industries will demand clear compliance. JetBrains’ approach integrates deeply with team workflows, security scanning, and code review rather than bolting on compliance as an afterthought.

Challenges and Opportunities Ahead

The road to 2026’s AI maturity isn’t without obstacles. Arun identifies standards coordination as the first major challenge—multiple competing protocols mean enterprises will need translation layers between translation layers, reminiscent of the “SOAP web services death star” era. “Can you actually run Claude plus GPT-4 plus a security agent in the same workflow without custom glue code? Most organizations can’t,” he observes.

A second challenge is the specification authorship gap. Writing good specs is a skill developers haven’t practiced in the move-fast era. “Organizations will discover their teams don’t know how to write specs that agents can execute effectively,” Arun warns. Writing for both human comprehension and agent execution requires new skills—one part for senior developers, another for junior developers and AI agents to implement consistently.

Orchestration complexity presents a third hurdle. Multi-agent workflows sound elegant but are operationally nightmarish. Which agents run when? How do you handle conflicts between agent outputs? Who debugs when three agents touch the code? “When the security agent flags 30 issues in code the implementation agent just wrote, can your system resolve it automatically, or does it create additional work?” Arun asks.

Cultural resistance rounds out the challenges. This transition requires developers to change from hands-on coding to spec writing and agent orchestration. “Many experienced developers will resist becoming conductors because it doesn’t feel like real programming,” Arun notes. Organizations may split into factions: AI natives who embrace agents and craft people who see this as skill degradation.

Yet these challenges create significant opportunities. Someone needs to solve the integration layer problem—the m×n challenge of making competing standards work together. “Companies that make interoperability work, like Stripe did for payments, will thrive,” Arun suggests. JetBrains’ approach with ACP transforms m×n integrations into m+n by providing a universal adapter for agent-IDE integration.

The specification tooling market is nascent and ripe for innovation. Writing good specs is a learned skill most developers lack, creating demand for intelligent tooling that validates specs, suggests missing details, and translates business requirements into agent-executable formats. “How can you create a Grammarly for software specification?” Arun asks.

Governance-as-a-service represents another major opportunity. Enterprises can’t build governance frameworks from scratch—it’s not their core competency. Turnkey solutions offering policy templates, pre-built audit dashboards, and compliance certifications will be essential. JetBrains doesn’t build governance policies but becomes the enforcement point, ensuring agents can’t bypass established rules.

Actionable Advice for 2026

Arun’s recommendations are direct and practical. First, start learning the art of writing specifications now, even if you’re not using agents yet. “Pick two or three upcoming features and require writing specs before implementing,” he advises. Don’t aim for perfection—aim for practice. Experiment with coding agents to help write good specs and implementation plans, with developers as the human in the loop. “If you wait until you adopt AI agents to start writing specs, it’s too late.”

Second, audit your tool chain for interoperability standards. “If your tool chain is locked into proprietary formats, you will be stuck,” Arun warns. Inventory every development tool: does it support open standards or proprietary APIs? Test a simple workflow—can you move context from your IDE to CI/CD and code review tools without manual export/import? Identify highest-risk vendor lock-ins and create migration contingencies. Success means swapping one AI coding tool for another without rewriting your entire workflow.

Third, budget for the transition dip. Every organization underestimates the J-curve—productivity will dip for the first three to six months as teams learn new workflows before climbing above baseline. “Set realistic expectations with stakeholders that we’re going to be slower in Q2 and Q3 but will get faster in Q4,” Arun emphasizes.

Finally, set up AI code governance now. Create a cross-functional role spanning engineering, legal, and compliance. Start with basic questions: what audit trail do we need for code? Who approves AI-generated code? What’s our policy on AI touching security-critical code?

For those not ready to commit, Arun is honest about the wait-and-see option: “If you adopt in 2027–2028, when standards have stabilized and best practices have emerged, you’ll end up paying consultants to implement what early adopters learned for free. Be on the bleeding edge. Play with it. You will fail, you will stumble, but you will recover—and you’ll run faster.”

JetBrains’ 2026 Focus

With nearly 26 years of experience navigating major transitions—from Java to Kotlin, manual to automatic refactoring—JetBrains is positioning itself as the trusted guide through AI development’s evolution. The company is building production-ready ACP implementation across JetBrains IDEs and working with partners to integrate coding agents. The recently launched ACP client registry includes models from Augment, Code Gemini, Copilot, Mistral, Qwen, and others, making any ACP-compliant agent available in JetBrains IDE 2025.3 and beyond.

“We give you choice, control, and transparency in what you’re using,” Arun says. JetBrains offers a bring-your-own-key model, allowing developers to use their own cloud credentials. The company is also exploring native spec-driven development workflows and agent orchestration hubs that coordinate agents running on desktop and in the cloud.

Governance remains critical. JetBrains focuses on giving customers control over which models are allowed and which are not, without restricting themselves to Juni, their own coding agent. “We are not creating our own proprietary agent format. We are betting on open standards because vendor lock-in hurts customers,” Arun emphasizes.

The company’s North Star has always been developer productivity, and that won’t change. “We won’t claim AI will replace developers or give you 10x productivity overnight,” Arun says. “We are focused on sustainable, governable, maintainable, AI-assisted development.”

As 2026 unfolds, the shift from chasing AI-driven speed to prioritizing quality and reliability will separate organizations that thrive from those that struggle. The prediction is clear: quality and reliability always trump velocity—and that focus on quality will ultimately make developers more productive.