When GitLab CEO Bill Staples announced “Act 2” a few days ago, most of the headlines focused on the obvious stuff. Layoffs. Restructuring. Geographic pullbacks. AI agents. Efficiency. The usual collection of terms that now seem mandatory whenever a software company announces its plans for the agentic era.
But I think the real story is bigger than that.
The real question is whether GitLab can reinvent itself for the next era of software development without losing the cultural infrastructure that made it one of the defining companies of the DevOps movement in the first place.
That may sound dramatic, but for those of us who have watched GitLab since its earliest days, this is not just another software company making another AI pivot. GitLab was different. It represented something different. And judging by the reactions from customers, former employees and practitioners across the industry, people instinctively understand that something more significant is happening here.
To understand why, you have to go back to the beginning.
When GitLab first burst onto the DevOps scene, it felt like a breath of fresh air. This was a company that came out of Y Combinator with what sounded at the time like a borderline crazy idea. Not just open source software. An open source company.
Founder Sid Sijbrandij and the early GitLab team built a company that was practically an open book. Their handbook was public. Their org charts were public. Their roadmap was public. Their thinking was public. You could often see who worked there, what they worked on, who they reported to and where the company was heading next.
In some cases, you could even see compensation bands and hiring rationale. In an industry where most companies operated behind carefully managed PR walls, GitLab was radically transparent.
And DevOps people loved it.
They bought into the idea that software development and delivery could be collaborative, iterative and community-driven. They contributed code. They evangelized the platform. They trusted the company enough to help build the product itself.
That trust mattered.
Because DevOps was never just about tooling. Despite what some vendors eventually turned it into, DevOps at its core was about reducing friction between humans trying to build and ship software. It was about transparency, feedback loops, documentation, iteration and shared ownership.
GitLab didn’t just sell those ideas. For a long time, it embodied them internally.
The company grew rapidly, becoming one of the dominant DevOps platform providers in the market. As the industry evolved from DevOps into DevSecOps, GitLab was right there helping define that transition, too. They eventually became the first pure-play DevOps company to go public. Sure, there were already public companies doing DevOps-related business. But GitLab was different. GitLab was born DevOps-native.
And all through that growth, they kept shipping. Every month, new releases. New capabilities. New integrations. New functionality.
It felt less like a conventional enterprise software company and more like a living software organism.
A lot of that culture traces back to Sid himself. Beyond building GitLab, he helped pioneer the idea that remote-first, asynchronous, documentation-driven companies could operate at massive scale. Long before remote work became mainstream, GitLab was proving that distributed organizations could work if the systems behind them were designed intentionally enough.
Unfortunately, Sid’s journey also took a deeply personal turn when he was diagnosed with cancer. True to form, though, Sid approached it with the same transparency and intensity that characterized much of GitLab’s culture. As he has described publicly, he essentially “startup-ed” his cancer battle, documenting the process, the decisions, the treatments and the mindset behind it in remarkable detail. Thankfully, that effort appears to have been successful, and his story remains both courageous and inspiring for anyone facing serious health challenges. Eventually, Sid stepped away from day-to-day leadership to focus on his health while remaining involved as executive chair. If you have not read his account, it is worth spending some time on Sid Sijbrandij’s LinkedIn profile.
In many ways, that transition marked the symbolic end of GitLab’s founder era.
But the company kept moving forward with strong leadership across the organization. People like Ashley Kramer, David DeSanto and many others helped continue GitLab’s momentum and innovation cadence. The platform matured. The business matured. The market matured.
And over time, GitLab also became something else.
It became a case study in culture as operational infrastructure.
That may sound abstract, but my friend Brendan O’Leary captured it well when he left GitLab in 2022 and later reflected on what made the company work.
In his excellent essay, “12 GitLab Lessons”, Brendan described a company whose values were not just HR slogans hanging on walls. They were operational systems. GitLab’s CREDIT framework, Collaboration, Results, Efficiency, Diversity/Inclusion/Belonging, Iteration and Transparency, created the scaffolding that allowed a globally distributed software organization to function.
That distinction matters.
Because software organizations at scale are not just technology systems. They are social systems. The tooling matters, but the trust mechanisms matter too. Documentation matters. Communication norms matter. Transparency matters. Psychological safety matters. Shared ownership matters.
Those “soft” systems are often the difference between operational acceleration and operational chaos.
Which brings us back to Act 2.
Bill Staples is not some cartoon villain parachuted in from Wall Street to destroy GitLab culture. That would be lazy analysis. Staples has decades of experience running enterprise software organizations and developer-focused businesses. He is an experienced operator. He understands scale, execution and platform economics.
But he also comes from a different era and a different operating tradition than Sid.
And that difference shows up in the language and framing of Act 2.
The announcement positions GitLab for the agentic era. AI agents. Machine-assisted software delivery. Greater automation. Operational efficiency. Organizational restructuring. Geographic rationalization. Increased leverage.
Honestly, none of this is surprising.
Every software company of scale is trying to figure out what an AI-native future looks like. Every platform company is trying to determine how agents change workflows, staffing, economics and customer expectations. Every executive team is staring at the same combination of investor pressure, competitive pressure and technological disruption.
GitLab is not unique there.
What is unique is how openly GitLab is talking about it.
Most companies would bury this kind of transition inside sanitized earnings language and carefully lawyered corporate messaging. GitLab, true to its roots, still appears more willing than most to let people see at least part of the machinery while the transformation is happening.
They are still, at least to some degree, an open book.
That openness is one reason the reaction has been so intense.
A quick look through the Reddit discussion around Act 2 reveals a practitioner community that is far from universally enthusiastic.
Some reactions focus on cost anxiety around AI-driven development tooling. Others question whether the company is chasing growth or simply using AI language to justify workforce reductions. Others worry that GitLab risks becoming another consumption-meter platform where operational unpredictability becomes part of the business model.
One Reddit commenter wrote:
“That’s how you know it’s not about growth, expansion, improvements, none of that. It’s AI washing for layoffs.”
Another added:
“We ended up choosing Claude Code because of how expensive and unpredictable those costs are with Gitlab.”
And perhaps the most interesting reaction was not even about AI itself, but about identity:
“It’s interesting that they have a very unique opportunity to capitalize on pitching to org/businesses, who are very much feeling recent GitHub outages and the merge queue fiasco, and they are choosing to seize this opportunity by laying off.”
Now, Reddit being cynical about corporate change is hardly breaking news. DevOps practitioners are not exactly known for blind optimism toward vendor messaging. But dismissing these reactions as mere negativity would miss something important.
Operators can sense when the language of a company changes.
And many longtime GitLab observers hear a shift happening.
That is why Brendan’s recent LinkedIn comments resonated so strongly with people who have followed GitLab for years. In reacting to Act 2, Brendan wrote:
“The question isn’t whether those goals are right. It’s whether you can achieve them after removing the cultural scaffolding…”
That line cuts right to the heart of the issue.
Because GitLab’s culture was not ornamental. It was functional.
Transparency reduced friction. Documentation enabled asynchronous scale. Iteration accelerated delivery. Shared context reduced organizational drag. CREDIT was not branding. It was infrastructure.
Brendan also wrote:
“Retiring Transparency as a core principle at the company that literally built its identity on a public handbook? That’s the part that stings.”
Again, this is not nostalgia talking.
It is a concern about institutional drift.
As with most successful technology companies, GitLab is evolving. Startups become platforms. Platforms become public companies. Public companies eventually face the pressures of operational scale, investor expectations and market shifts. The language changes. Priorities shift. Incentives evolve. Sometimes those transitions strengthen a company. Sometimes they hollow it out. Usually, the outcome lands somewhere in between.
What makes GitLab particularly interesting right now is that this transition is happening at the exact moment the software industry itself is changing underneath it. DevOps is steadily evolving into AI-native software operations. Developers are beginning to work alongside agents instead of simply using tools. Platform engineering is moving beyond internal developer portals toward orchestrating increasingly automated workflows. Even the economics of software platforms are changing as companies experiment with consumption-based AI models instead of traditional seat licensing.
GitLab did not create these industry shifts. Every major software company is trying to navigate the same terrain right now. But because GitLab has historically been more transparent than most, people are getting a much clearer look at what that transition actually looks like inside a real company trying to adapt in real time.
Ironically, many of the disciplines GitLab pioneered may actually become more important in an AI-native world, not less. Documentation. Transparency. Clear workflows. Shared context. Iteration. Async coordination. Those are exactly the kinds of systems organizations need when humans increasingly supervise distributed networks of agents and automation.
Which is why this moment feels so consequential.
GitLab may be trying to transition from a company optimized around helping humans collaborate on software into a company optimized around orchestrating machine-assisted software delivery at scale.
That is not a small pivot.
That is a redefinition of what the company fundamentally is.
And yet, despite all the uncertainty, despite the layoffs, despite the skepticism and despite the understandable anxiety, I still find myself rooting for GitLab.
Partly because I respect companies willing to adapt instead of pretending the world is standing still.
Partly because I still think GitLab represents many of the best instincts of the DevOps movement.
And partly because even now, during what is clearly a difficult and disruptive transition, they are still being more transparent than most companies would ever dare to be.
That matters.
Especially in an era where so many technology companies hide behind polished narratives while quietly making massive organizational changes behind closed doors.
Shimmy’s Take
Nothing stays static forever.
Not industries. Not technologies. Not companies. Not cultures.
The GitLab of today is not the same GitLab that first came out of Y Combinator and captured the imagination of the DevOps community. It probably should not be. The world of software development and delivery has changed too much for that.
Agentic AI is going to reshape software organizations whether people are comfortable with it or not. The economics, workflows and staffing models around software development are already changing in real time. Companies like GitLab have little choice but to adapt.
That adaptation will create winners and losers. Some good things may be lost along the way. Some people will absolutely feel betrayed by changes to a culture they deeply believed in. Some customers will decide the new direction is not for them.
All of that is real.
But I also think GitLab deserves credit for recognizing the scale of the transition happening in front of the industry and for attempting to remake itself accordingly instead of pretending incremental change will be enough.
The bigger question is whether they can do it while preserving enough of the operational philosophy that made GitLab matter in the first place.
Can a company remain an open book while rewriting itself for the agentic era?
We are about to find out.
