We called it a pitch pause. Two weeks where the product and engineering teams at Validic got dedicated time to stop, learn, and build with agentic AI tools. Others were welcome to join, and many did. No deliverables. No demos required. No pressure to produce anything shippable. Just time and permission to explore.
The idea was simple. People learn tools by using them on problems they actually care about. Not by watching a webinar. Not by reading a getting-started guide. By opening a terminal, or VS Code, or Claude Code Desktop, and building something.
Here’s what happened.
the numbers
43 new repositories in two weeks. A new shared AWS environment so people could deploy what they built without worrying about production infrastructure. Product and engineering were the core, but people from sales, support, and customer success jumped in too.
I want to be specific about what “43 repositories” means. It’s not 43 finished products. It’s 43 times someone had an idea, opened a terminal or VS Code or Claude Code Desktop, and started. Some of those repos are full applications with auth and deployment pipelines. Some are proof-of-concept tools that solved one specific problem. A few are documentation repos where someone figured out a workflow and wrote it down so the next person wouldn’t have to.
what people built
The range surprised me more than the volume. I expected engineers to build developer tools. They did. But the projects that stuck with me were the ones from people solving problems they’d been carrying around for months.
Internal tools people had wanted forever. Knowledge bases that made tribal knowledge searchable. Customer portals that replaced manual workflows. Pipeline dashboards that pulled data from three different systems into one view. These weren’t new ideas. They were old ideas that never made it to the top of the backlog because they weren’t customer-facing. When the cost of building dropped, people finally built them.
Developer productivity tools. Log viewers that simplified Kubernetes debugging. Desktop UIs for interacting with message queues. Deployment automation that turned a 20-step runbook into a single command. The kind of internal tooling that engineering teams always say they’ll build “when we have time.”
Sales and demo tools. API consoles for testing integrations live during customer calls. Presentation generators that built slide decks from templates. Demo applications that showcased the product without touching production data. The sales team didn’t wait for engineering to build these. They built them themselves.
Creative and cross-functional projects. A step-tracking app with leaderboards that turned fitness data into a company-wide competition. Audio analysis tools. Slack bots that automated repetitive team communication. A shared authentication platform so all the lab apps could use single sign-on.
Infrastructure and guides. Getting-started documentation. Configuration best practices. Shared deployment patterns so the next person could go from idea to deployed app even faster. People didn’t just build for themselves. They built ramps for the people behind them.
the happy hour
We held a 90-minute happy hour at the end where people came and shared what they built. I’ve been in a lot of demo sessions over the years. Sprint reviews, innovation days, hackathon presentations. This one was different.
The energy was different. People weren’t presenting to justify time spent. They were genuinely excited to show something they made. The support engineer who built a knowledge base that would save their team hours every week. The salesperson who built a demo tool that let them show the product the way they’d always wanted to. The engineer who finally automated that one painful deployment they’d been doing manually for a year.
Most of what people built were things they had wanted to do forever. The pitch pause didn’t give them ideas. It gave them permission and time.
what I learned
I went into this with one goal: people have a designated, safe time and place to learn and explore. Everything else was gravy. It went better than I expected.
The activation energy observation held up across the whole organization. When the cost of starting drops to nearly zero, people stop filtering ideas. The things they would have talked themselves out of, the “nice to have” tools, the “maybe someday” improvements, those are exactly the things they built first. Because those are the things they actually cared about.
The other thing I didn’t expect: how liberating it was for people to work outside their normal constraints. Production development has rules. Code review processes. Sprint commitments. Architecture standards. All of those exist for good reasons. But they also create a box. The pitch pause let people step outside that box. Go deeper into unfamiliar territory. Explore farther abroad from their usual domain. An engineer who normally works on backend infrastructure built a frontend app. A support team member who doesn’t write code built a working tool. People surprised themselves.
what’s next
Two weeks isn’t enough. These creative sessions need to become part of how we work, not a one-time event.
We’re figuring out what that looks like. Regular dev days. Dedicated exploration time. Some structure that makes it sustainable without making it feel like another process. The details matter less than the principle: teams that get safe space to experiment build things that matter to them. And things that matter to them tend to matter to the company.
Two weeks. 43 repos. Boundless creativity and energy. The pitch pause is over. The building isn’t.