Ricardo Brandão – Senior Software Engineer and Team Lead
The Problem That Started It All
Picture this: It's 2 PM, you're deep in flow state debugging a complex algorithm, when suddenly you remember – you need to check if your PR from yesterday got any feedback. You alt-tab to GitHub, scan through comments, realize you need to update a Jira ticket status, open another browser tab, then remember you should probably review that PR your teammate assigned you this morning. Twenty minutes later, you're staring at your IDE wondering what you were even debugging.
Sound familiar?
Our team of 7 developers was living this reality daily while working on a high-stakes client project. Management was breathing down our necks about improving our DORA metrics – deployment frequency, lead time, and change failure rate needed serious attention. But here's the kicker: the very tools meant to help us track and improve these metrics were actually sabotaging our productivity through constant context switching.
We were bouncing between VS Code, GitHub, Jira, and Slack dozens of times per day. Each context switch wasn't just costing us minutes – it was fragmenting our focus and making us slower, not faster.
That's when we decided to build something that would change everything.
The Challenge: Understanding Our Client's Unique Workflow
Working in healthcare SaaS isn't like building your typical web app. Our client operates in a heavily regulated B2B environment where HIPAA compliance isn't just a checkbox – it's baked into every decision we make. When you're handling sensitive patient data, you can't just install whatever productivity tool catches your fancy.
The technical landscape was equally complex: a sprawling microservices architecture spanning multiple repositories, with four different development teams contributing code across the entire ecosystem. Each team had organically developed their own workflows and "productivity hacks" to deal with the pain, but nothing was standardized or scalable.
As team lead, I knew we needed data, not assumptions. We started with Developer Experience (DX) surveys across all teams, diving deep into daily frustrations and time sinks. I spent weeks analyzing our DORA metrics, looking for patterns in deployment delays and change failure rates. The real insights came from 1x1 conversations with individual developers and strategic discussions with other team leads.
What emerged was a picture of death by a thousand paper cuts. Our GitHub workflows required at least two approvers, zero failed tests, and all PR comments resolved before merge – reasonable requirements that were creating bottlenecks. Our Jira instance used custom fields and workflows specific to healthcare compliance tracking, meaning developers were constantly updating ticket statuses and compliance checkboxes.
The kicker? Because of HIPAA constraints, we couldn't just integrate with any third-party tool or service. Every solution had to be carefully vetted, often ruling out popular productivity tools entirely.
We realized that off-the-shelf solutions wouldn't cut it. We needed something purpose-built for our exact workflow, security requirements, and team structure.
The "Aha!" Moment: Why AI Was the Answer
The timing couldn't have been more perfect. This was late 2024, when AI had become THE buzzword and every software engineer worth their salt was exploring how to integrate it into their workflows. We weren't just riding the hype train – we were genuinely curious about how AI could solve real problems.
The breakthrough came during a particularly frustrating team meeting where we were once again discussing our productivity challenges. Someone mentioned how they'd been using ChatGPT to summarize meeting notes and auto-generate Jira acceptance criteria. That's when it clicked.
The biggest barrier to building custom developer tools had always been time. How do you justify spending weeks building internal productivity tools when there's an endless backlog of client features and product manager requests? It's a conversation every engineering leader has had with their stakeholders: "We could build something to help our developers, but it'll cost us X sprint cycles..."
AI changed that equation entirely. Think of it like 3D printing – suddenly you can create a disposable bracket for your chair that isn't perfect or pretty, but costs almost nothing and solves your immediate problem. AI became our development 3D printer.
Instead of weeks building traditional integrations from scratch, we could use AI to generate boilerplate code, write API integrations, and handle data transformations in minutes. We weren't just building AI-powered tools – we were using AI to accelerate the development of regular tools. Suddenly, the cost-benefit analysis flipped. We could create a suite of custom solutions – intelligent code review, automated Jira updates, contextual PR summaries – all without the massive time investment that would normally make such projects non-starters.
The realization wasn't about building the perfect enterprise solution. It was about AI removing the economic barrier that had kept us from solving these problems before. Good enough, fast, and cheap suddenly became possible.
Behind the Scenes: The Technical Architecture
Building a VS Code extension that needs to juggle AI providers, GitHub APIs, Jira integration, and real-time file monitoring required some thoughtful architectural decisions. The challenge wasn't just making it work – it was making it work reliably in a healthcare environment with strict compliance requirements.
Our first major decision was avoiding vendor lock-in with AI providers. Rather than tying ourselves to a single service, we built an IAIService interface that abstracts away the differences between Google AI and AWS Bedrock. This architectural choice proved invaluable during development when we started with Google AI's generous free tier for rapid prototyping, then seamlessly switched to AWS Bedrock once we had our BAA (Business Associate Agreement) in place for HIPAA compliance. The factory pattern in our extension activation handles provider switching based on user configuration, requiring zero code changes when we made the transition.
Traditional file watchers can be resource hogs, especially in large codebases, so we implemented an intelligent change detection system instead. Using SHA-256 hashing, we maintain a content map of open documents and only trigger processing when actual content changes occur – not just when files are touched or saved without modifications. This approach dramatically reduced unnecessary AI API calls during development, keeping our costs predictable.
The GitHub integration taught us an important lesson about API design evolution. Initially, we started with GitHub's REST API like most developers do, but we quickly hit rate limiting issues and found the data structure cumbersome for our specific use case. The breakthrough came when we switched to GraphQL – suddenly we could fetch exactly the data we needed (PR review threads, comment resolution status) in a single request instead of multiple REST calls. This reduced our API usage by roughly 70% and improved response times significantly.
The extension's UI evolved around VS Code's native tree view system, organized into collapsible sections for AI Reviews, Saved Changes, GitHub PRs, and Jira tickets. Each section uses dedicated provider classes that implement VS Code's TreeDataProvider interface, making the codebase modular and allowing us to develop features independently. This proved crucial when we needed to iterate quickly based on team feedback.
One of the more interesting challenges emerged around cost optimization. To minimize AI token usage, we implemented code minification before sending to AI providers – removing comments, extra whitespace, and unnecessary formatting. This cut our token usage by about 30-40%, but it created an unexpected problem: when the AI suggested code edits, they referenced the minified version, making them harder to apply to the original formatted code. We solved this by maintaining source maps and implementing a smart diff-matching algorithm that could translate suggestions back to the original code structure.
Security remained paramount throughout development. Given the HIPAA requirements, everything runs locally except for the AI provider calls. API credentials are stored using VS Code's secure secrets API, and we made sure no sensitive code or data gets logged. The AWS Bedrock integration uses standard AWS credential chains, supporting both explicit credentials and IAM roles for enterprise environments. The extension uses VS Code's event system extensively – configuration changes automatically reinitialize services, file saves trigger reviews, and all components properly clean up their resources when disposed, ensuring the extension remains responsive and doesn't leak memory during long development sessions.
The Magic in Action: Key Features & User Experience
The real magic happened when our developers stopped noticing the extension – it just became part of their natural workflow. The transformation was subtle at first, then suddenly obvious when we realized how much friction had simply disappeared from our daily routine.
Take PR reviews, for instance. The old dance was exhausting: a PR gets assigned to you, Microsoft Teams notification pings, you context-switch to the Teams channel, scroll to find the PR link, open GitHub in browser, navigate to the pull request, and finally start reviewing. Five minutes gone before you even see the code, and your mental context completely shattered.
Now the moment a review is requested, it appears in the extension's sidebar. One click takes you directly to the GitHub PR, but here's the killer feature that nobody expected would be so valuable – if you have that repository open in VS Code and click on a PR comment, it jumps you directly to the exact line being discussed. No more hunting through files wondering "where was that comment again?" The context switching went from minutes to seconds, but more importantly, the cognitive overhead simply vanished.
Our healthcare client's requirements around Dev/QA status tracking used to be a daily pain point. The meticulous tracking of custom support tickets meant developers spent 10-15 minutes each day manually updating fields one ticket at a time in Jira's web interface. It was tedious work that nobody enjoyed but everyone had to do for compliance.
The extension transformed this completely. A single collapsible list in the IDE sidebar shows all assigned tickets with their current status. Updating a ticket's Dev/QA status became literally two clicks – no browser tabs, no Jira navigation, no context switching. What used to be a daily chore became a 30-second task that developers could handle without breaking their coding flow.
The feedback from our team was unanimous: they loved being able to stay in VS Code throughout their entire workday. As one developer put it, "I forgot how much mental energy I was spending just managing all these different tools." The extension became their central command center – checking PR assignments, updating ticket statuses, getting AI code reviews, all without leaving their coding environment.
Numbers don't lie: our Developer Quality of Life survey showed a 20% improvement among team members using the extension compared to the previous cycle. But beyond the metrics, you could feel the difference – less frustration during standups, fewer complaints about "process overhead," and developers who were genuinely excited about a productivity tool. This wasn't just about saving clicks or reducing time – it was about preserving the developer's mental flow state. When you can handle all your peripheral tasks without leaving your code editor, you stay in the zone longer and do better work.
Lessons Learned: What We'd Do Differently
Building this extension taught us lessons that went far beyond just solving our immediate workflow problems. The experience reshaped how we think about approaching similar projects and what's possible when you combine human creativity with AI capability.
The biggest surprise was how AI democratized complex development tasks that used to be intimidating. VS Code extension development went from being a complete black box to totally approachable, thanks to AI assistance. Before this project, building extensions seemed like it would require weeks of documentation diving and API spelunking. AI didn't just help us write code – it became our guide through unfamiliar territory, explaining concepts and suggesting patterns as we went. This dramatically shortened our research and learning curve, turning what felt like a major undertaking into an achievable weekend project.
Looking back, there's one architectural decision we'd probably change. If we started over, we'd likely begin with a webview panel instead of centering everything around VS Code's tree view. The tree view works great and gave us rapid initial development, but it has inherent limitations for complex layouts. A webview would be more work upfront but offer significantly more flexibility for future features. Sometimes the "quick start" path creates constraints you don't anticipate until you're deep into development.
One of our best decisions was treating this as a true internal tool from day one. Since we were building for ourselves, testing happened live – new pain point? Add a feature. Bug encountered? Fix it immediately and push an update. No formal QA, no client complaints, just rapid iteration based on real usage. This approach works brilliantly for internal tooling where the developers are also the users, but it required us to embrace a different development philosophy than our usual client work.
Not every feature landed as expected, though. Our saved changes tracking and AI analysis turned out to be less useful than anticipated, especially since our team primarily uses Cursor for day-to-day development. Cursor's built-in AI capabilities often proved more cost-effective than our direct AI integration. This reminded us to validate feature assumptions early and often, even when building for ourselves.
The adoption pattern was fascinating to watch unfold. We started with our 7-person white-label team, then other developers across the 40-person organization saw how much easier our daily tasks became. Now we have 36 installs across all teams – proof that good tools sell themselves when they solve real problems.
The Bigger Picture: AI in Custom Development
We're witnessing a fundamental shift in how software development works, and it's not just about writing code faster. AI is democratizing custom tool development in ways that are reshaping competitive landscapes across the industry.
Think of software developers like craftsmen – sometimes a carpenter needs to build a custom jig to cut a specific joint efficiently. Traditionally, only FAANG companies and large enterprises could afford to build sophisticated internal tools. The research cycles were too expensive, the implementation too time-consuming for smaller teams to justify. AI is changing that equation entirely, acting as the great equalizer in technology development.
When a 7-person team can build enterprise-grade productivity tools in hours instead of months, the competitive moats that big companies relied on start to crumble. Smaller and medium companies now have access to the same "custom tooling" capabilities that were once exclusive to tech giants. The quicker research cycles and rapid implementation that AI enables are leveling the playing field in unprecedented ways.
We're already seeing this disruption play out in real-time. Smaller startups are pulling the rug out from under established players like Microsoft by cleverly leveraging AI to build solutions that would have required massive engineering teams just a few years ago. The question isn't whether this disruption will happen – it's happening now, and the pace is only accelerating.
The critical insight we've learned is that we're treading a careful line between "vibe-coding" and genuinely productive AI collaboration. The future isn't AI writing all our code unsupervised – that leads to technical debt and unmaintainable systems. Instead, it's software engineers working symbiotically with AI, providing direction, validation, and strategic thinking while AI handles implementation details and boilerplate generation.
Smart companies are identifying the low-hanging fruit that AI can now solve almost instantly. By clearing these productivity bottlenecks off developers' plates, teams can focus their human intelligence on the complex problems that actually drive business value. Our extension is just one example – what used to be a "nice to have" internal tool became a quick weekend project that delivers measurable value.
The companies that recognize this shift and act on it will have a significant advantage over those that continue treating AI as just another development tool rather than a strategic equalizer that can fundamentally change what's possible for small and medium-sized development teams.
This extension started as a solution to our own frustrations, but it represents something bigger – the power of combining human creativity with AI capability to solve real problems quickly and efficiently.
If you're facing similar challenges with your development team's workflow, or if you're curious about how AI can accelerate your custom development projects, we'd love to have a conversation. We're not interested in being just another development vendor – we prefer working as strategic partners who understand that the best solutions come from collaboration, not specification documents.
Whether you're dealing with productivity bottlenecks, integration challenges, or exploring how AI can transform your development processes, we approach every project as problem solvers, not code factories.
Interested in exploring what's possible? Reach out to us directly. Connect with us on LinkedIn.
Let's build something impactful together.
EN 
PT