How to Revolutionize Your Engineering Team for the Agentic Era: A Practical Guide from Braze's CTO

What You Need

• Leadership commitment: Support from C-level to champion the transformation
• Engineering team buy-in: Willingness to experiment and adapt
• AI tools and platforms: LLMs, code assistants, AI-augmented testing frameworks
• Training resources: Internal workshops, online courses, or external consultants
• Iterative mindset: A culture that embraces rapid prototyping and learning from failure

Introduction

When Jon Hyman, co-founder and CTO of Braze, looked at the rising tide of artificial intelligence, he didn't just tinker at the edges. He led a fundamental rethinking of how engineering works—transforming Braze from a traditional team into an AI-first engineering organization in just a few months. This guide distills the core steps he and his team followed, offering you a proven roadmap to adapt your own engineering practices for the agentic era—where AI agents work alongside humans to build, test, and ship software.

Step 1: Establish an AI-First Vision

Start by painting a clear picture of what AI-first engineering means for your company. Hyman didn't treat AI as a separate initiative; he made it the central operating principle. Communicate that every engineering decision—from coding to deployment—should default to leveraging AI where possible. Define measurable goals: e.g., reduce cycle time by 30% within a quarter using AI-assisted code generation. Get leadership alignment and share the vision across teams.

Step 2: Assess Your Current Engineering Processes

Before diving into AI, map your existing workflows. Identify repetitive, time-consuming tasks such as:

• Code reviews and debugging
• Test generation and execution
• Documentation writing
• Deployment and monitoring

Prioritize areas where AI can deliver immediate impact. Hyman's team likely started with high-friction points like manual testing or boilerplate code. Use a simple scoring matrix: effort reduction vs. value to the business.

Step 3: Choose and Integrate AI Tools

Select tools that fit your tech stack and team culture. At Braze, this meant adopting large language models (LLMs) for code generation, AI-powered testing suites, and intelligent alerting systems. Integration tips:

1. Start with one or two tools to avoid overwhelm.
2. Use pilot teams to test effectiveness before widespread rollout.
3. Ensure tools complement existing CI/CD pipelines—not disrupt them.

For example, integrate an AI code assistant like GitHub Copilot into your IDE and measure its impact on developer velocity over a two-week sprint.

Step 4: Reskill and Upskill Your Engineering Team

Transformation requires people change. Hyman invested in training programs that taught engineers how to prompt AI models effectively, interpret AI-generated code, and evaluate its quality. Create a learning path:

• Foundational: AI literacy for all engineers (e.g., how LLMs work, ethical considerations)
• Intermediate: Practical usage—writing prompts for code generation, reviewing AI outputs
• Advanced: Building custom AI agents that own specific tasks like regression testing

Schedule weekly knowledge-sharing sessions where teams present AI wins and failures. This builds collective intelligence and normalizes experimentation.

Step 5: Redefine Team Roles and Collaboration

In an AI-first world, the role of a developer shifts from writing every line of code to orchestrating AI agents. Restructure teams to include:

• AI specialists who train and fine-tune models
• Prompt engineers who craft effective instructions for AI agents
• Reviewers who audit AI outputs for security and quality

Encourage cross-functional collaboration—pairing a senior engineer with a machine learning expert on a single squad. Hyman's approach was to embed AI expertise into existing teams rather than creating isolated AI teams.

Step 6: Implement Iterative Experimentation

Braze's transformation didn't happen overnight; it was a series of small, fast iterations. Set up a structure for experimentation:

1. Define a hypothesis (e.g., “Using AI to auto-generate unit tests will reduce bugs by 20%”).
2. Run a two-week sprint with a pilot team using the new AI tool.
3. Measure results (velocity, bug rate, developer satisfaction).
4. Learn and scale what works; discard what doesn’t.

Create a fail-fast culture where teams feel safe to abandon ineffective AI tools. Document lessons learned in a shared repository.

Step 7: Measure Impact and Adapt

Without metrics, transformation is guesswork. Track both leading and lagging indicators:

• Leading: Number of AI-generated code commits adopted, percentage of tasks with AI assistance
• Lagging: Deployment frequency, time to recovery, customer satisfaction

Hyman's team used data dashboards to correlate AI adoption with engineering productivity. Adjust your tooling and training based on what the data says. For instance, if AI helps with code generation but slows down review cycles, invest in better review processes or more sophisticated AI outputs.

Tips

• Start small, scale fast: Resist the urge to overhaul everything at once. Pick one process (e.g., automated testing) and prove value before moving to the next.
• Focus on high-impact areas: Target tasks that consume 80% of your team's effort but bring 20% of value—AI thrives there.
• Encourage experimentation: Create “AI days” where developers can explore new tools without delivery pressure.
• Maintain agile principles: AI tools are enablers, not replacements. Keep your sprint cadence, standups, and retrospectives—they provide structure for iterative improvement.
• Share successes publicly: When a team reduces testing time by 50% using AI, celebrate it. This builds momentum and attracts more buy-in.

Transforming your engineering organization for the agentic era doesn't require years—just focused leadership, willing teams, and the right steps. Follow this guide, and you'll be on a path similar to what Jon Hyman achieved at Braze: an AI-first operation that ships faster, innovates more, and prepares for an agent-driven future.