Enterprise AI-First Development Adoption for a Telecom Company
A multi-month consulting and training engagement with a global enterprise company specializing in telecom measurement and service assurance. I moved from structured workshops into embedded mentoring across Java, C++, QA, and telecom engineering teams, working on their repositories and development workflows.
Client: Global Enterprise (Telecom Measurement & Service Assurance)
At a Glance
- Client
- Global telecom measurement company
- Duration
- 3 months
- Format
- 3 workshops + 15 embedded sessions
- Stack
- Java, C++, JavaScript
- Infrastructure
- GitLab, IntelliJ IDEA, on-prem delivery
- Teams
- 6 development teams
The Challenge
The client is a global enterprise company specializing in telecom measurement and service assurance. Their development teams work across Java, C++, and JavaScript codebases, use GitLab for version control, IntelliJ IDEA as the primary IDE, and deliver software under on-premises and private-cloud security constraints.
Leadership wanted to bring coding agents into a heterogeneous stack while preserving security, data governance, and the workflows already serving each team. The engagement covered shared-branch development, dedicated end-to-end testing with broad product coverage, and several repository and toolchain configurations. I focused on adding traceability and faster feedback without forcing every team into the same process.
I was brought in to run structured training, then stay embedded with individual teams to make coding agents productive on their actual codebases and workflows.
Solution Approach
Phase 1: Structured training
I ran three workshops with the development teams. The first covered coding-agent workflows end to end: from a tracked issue to a technical plan, a feature branch, implementation, and a GitLab merge request. The second focused on context engineering and reusable skills, showing teams how to encode project knowledge so agents produce better results from the start. The third introduced tool calling, MCP (Model Context Protocol), and controlled access to enterprise systems.
The workshops were hands-on. In one session, teams produced four to five merge requests on a shared Java project, with plans attached to issues for auditability. The same workflow was then applied during the embedded sessions on internal repositories.
Phase 2: Embedded mentoring
After the workshops, I ran fifteen working sessions embedded with Java, C++, QA/testing, and telecom engineering teams. Each session focused on that team's actual codebase and toolchain.
I built project context files grounded in the teams' repositories and internal technical manuals, created reusable skills and playbooks, and helped establish repeatable workflows: issue to technical plan to branch to GitLab merge request. Some of this work addressed multi-repository coordination and Maven dependency management, including security remediation.
Workstream Details
Automated Merge Request Review in GitLab
I built a successful end-to-end proof of concept for automated merge request review: Claude Code analyzed a merge request diff and published feedback directly in GitLab. I also defined the operating guardrails around it: tight tool permissions, personal developer tokens for attribution, an explicit note on AI-assisted changes, and human review before merge.
The automated MR-review POC also gave one C++ team a concrete path toward branch-based merge-request workflows, adding traceability and making their development process more agent-friendly.
Testing and Developer Feedback
The existing end-to-end testing setup was run by a specialist team and optimized for broad coverage across the product using Selenium-based tests in dedicated repositories.
I designed a complementary faster-feedback track to bring test results closer to the development cycle: Playwright-based UI tests with mocked external services, strategies for modernizing legacy and flaky tests, and making test results available as diagnostic context for coding agents. The goal was to let agents and developers use test outcomes while work was still in progress, complementing the broader E2E suite.
Reproducible Build Environments
I designed a "local Docker equals CI" approach to standardize build and verification across developer machines and the CI pipeline. This covered Java version pinning, Maven settings, external configuration, and consistent verification commands. When a coding agent and a CI server both run the same containerized environment, "works on my machine" stops being a failure mode.
C++ Review and Debugging
The C++ teams found the strongest value in coding agents as reviewers and debugging assistants. Sessions covered log analysis, sanitizers, memory leak detection, undefined behavior, performance profiling, memory layout, concurrency issues, regressions from version drift, and navigating multi-repository codebases.
I explored a diagnostic workflow using CLion, clangd, and LSP integration as a direction for giving agents richer access to compile-time and static-analysis information. This was design work and an investigation into what is possible, not a finished deep integration.
Telecom Engineering Pilot
I scoped a small human-in-the-loop pilot with the telecom engineering team. The proposed workflow starts from technical specifications, checks them for completeness, generates proprietary data-transformation artifacts from paired examples, and validates the result with existing parsers, compilers, and mock data. The design keeps domain experts responsible for review and approval.
Legacy Modernization Analysis
Later in the engagement, I analyzed a legacy Java application backed by a relational database for release management. I ran the system locally, identified application-side full-catalog loading and filtering as a performance root cause, and compared two remediation paths: tactical fixes (SQL optimization, indexing, pagination) versus an incremental modernization to Java 21, Spring Boot, and a React frontend. I recommended a phased, backward-compatible rebuild that would let the team migrate incrementally without disrupting ongoing operations.
Private and On-Premises AI Advisory
The company's security constraints required careful evaluation of how AI models would be deployed and accessed. I evaluated SaaS versus local and open-weight model options, assessed existing internal GPU capacity, and provided guidance covering model quality for coding tasks, GitLab and IDE integration paths, network isolation, role-based access control, audit logging, data and telemetry handling, legal jurisdiction of contracting and API-credit entities, operational resilience, total cost of ownership, and sovereign/private-cloud requirements. This was an evaluation framework and pilot planning exercise, not a completed on-premises deployment.
Results & Impact
- Four to five merge requests produced during hands-on workshops, with plans linked to issues for full auditability
- Successful end-to-end proof of concept for automated merge request review in GitLab with human oversight and traceability
- Project context files, reusable skills, and playbooks built across multiple repositories and teams
- Concrete implementation tracks defined across a heterogeneous Java/C++/JavaScript stack, covering GitLab workflows, testing, reproducible builds, and on-prem deployment
- Participation grew across six development teams, with review and debugging workflows generating the most engagement
- Engagement progressed from classroom training to embedded work on real legacy modernization cases
- Evaluation framework produced for private/on-premises AI deployment covering security, governance, and operational requirements
Tools and Practices
- Claude Code (coding agent + automated MR review)
- GitLab (merge requests, CI/CD integration)
- Java / Maven / Spring repositories
- C++ diagnostics: logs, sanitizers, clangd/LSP evaluation
- MCP training and controlled enterprise tool access
- Docker strategy for reproducible environments
- Playwright UI-testing design
- 3 workshops + 15 embedded mentoring sessions
"Guido was practical and thoughtful throughout the engagement. He was equally effective with junior developers and with engineers with more than twenty years of experience, adapting his delivery to each person and team."
Engineering Lead
Global enterprise telecom company