We build first-party integrations in Golang to help people easily connect tools like Slack directly to Tempest, without having to create custom apps from scratch. But we're a small team, and even simple integrations add up fast. I wanted to help lighten the load, so over the course of about a week, I managed to build eight integrations using an AI coding assistant. 

Here's the catch: I'm not a Golang engineer, I’m a frontend developer, and building the best possible user experience for Tempest is still where I’m putting most of my effort. That means my time was limited, and I couldn't constantly interrupt my team for help. To succeed, I had to develop a reliable, efficient method for working with AI—one that let me quickly fix mistakes, iterate efficiently, and ship production-ready code despite not being a master Golang hacker. 

I want to share exactly how I did it, what I learned along the way, and some tips for anyone else looking to make the most of AI-driven development.

My experience leveraging AI in my day to day work and in my personal projects has taught me that for simple things like building and integrating an API into an app—a not inconsequential subset of the workload in most engineering orgs—AI rewrites the rules. If a good engineer with general knowledge but no language or domain-specific knowledge can nonetheless churn out production-ready code at a pace once reserved for experienced, 10x engineers, the game has changed.

A few caveats 

Before I get too carried away with the AI praise, though, I do think it's important to be very clear about the context. Large Language Models aren't magic, even though they sometimes feel that way for a subset of tasks. I'm speaking mostly to the engineering managers reading this right now: don't think that AI means you can buy your frontend org a Cursor subscription and have them refactor the Cobol at the heart of your payments systems. The results I got from working with AI are definitely not generalizable to every possible development task.

But when it works, it really works, and creating integrations in Tempest happens to be particularly well-suited to AI assistance, largely thanks to our robust Golang SDK. This SDK simplifies the task, turning it into a structured translation exercise—something large language models are uniquely suited to.

Moreover, Go itself is ideal for AI development, given its clear, statically typed syntax. Its simplicity reduces ambiguity, helping AI produce accurate, effective code quickly. Additionally, Go's rapid compiler feedback enables immediate error correction, dramatically speeding up iterations from hours to mere second.

Private apps in Tempest already put a lot of power in developer’s hands without requiring a ton of development overhead. But when you factor in AI, it’s really pretty amazing what you can get done. 

My workflow: From concept to production-ready code

Even with a task and a language uniquely suited to AI coding, there’s still a learning curve with these technologies. My initial approach was to treat them sort of like a code dispenser—spend a lot of time writing the prompt, and if it didn’t give me what I wanted, refine the prompt until it did. 

But I found that’s not the best strategy. While it’s true clarity, explicitness, and concretely defined requirements are extremely important, and you have to put the work in up front to achieve that in your prompt, a good prompt alone will never get you all the way to your goals. Instead, AI really shines when you use it to iterate on the code itself through rapid cycles with tight feedback loops.

This is the biggest point people miss about AI development. It isn't so much that the code is always perfect from the moment you generate it. Actually, the first thing you get back is often pretty bad. Even in my case, where I was working with the platonic ideal of an AI vibe coding use case, about half the time the code the AI produced would fail to compile. 

However, when you work with an AI coding assistant, it becomes much easier, and much faster, to fix mistakes. What would normally have taken hours to fix took minutes. That means bad code becomes good code crazy fast. Sure, it might take 30 iterations to get your vibe code into a usable state. But if you can do those 30 iterations in half the time it would have taken to produce a single try on your own, that's still a huge net boost to your overall productivity. 

To illustrate exactly how my AI-assisted workflow evolved, let's consider a hypothetical example: building an integration for Slack using its public API. This use case encapsulates each critical step, highlighting both the process and tools involved.

• Initial Research: First, I'd dive into Slack’s API documentation to understand key elements like channels, messages, and user interactions, the building blocks that I had to work with. Initially, I did this manually, but later realized AI could summarize this and significantly accelerate this phase by sifting through the documentation for me and highlighting just the necessary information. 

• Drafting a Clear Product Spec: This step turned out to be absolutely crucial. Rather than vague descriptions, I learned to provide very explicit, detailed specs to the AI, which usually were a couple paragraphs long. I also provided it with one or two examples of what I was looking for—AI sometimes struggles to give you exactly what you need even with a fairly detailed spec, but providing an example radically improves accuracy.  

• Generating Initial Code: With the product spec ready, I'd feed it into Cursor, my AI coding assistant. Cursor leveraged the clarity of my spec to generate a nearly complete Go implementation using our Tempest Golang SDK and Slack's API.

• Quick Manual Review: Before testing, I'd quickly skim through the generated code, checking for any obvious misunderstandings or missing functionality. Given a clear initial spec, this was usually brief.

• Real-World Testing and Iterative Refinement: If the initial code passed the smell test, I'd try to compile it. Often, the first try wouldn't compile, but Go’s precise compiler feedback allowed rapid identification of errors. I'd feed these specific error messages back into Cursor, prompting it to iterate quickly and automatically fix them.

• Establishing Guardrails: When there was a style error or something simple, I'd explain what was wrong to the AI and have it fix it. Then I'd have it write an explicit rule to follow that addressed the error which I'd include in the system prompt going forward. That way, not just the code I was writing but the AI assistant itself improved over time. By the end, I was getting much cleaner and more compliant code on the first try. 

• Final Polishing: Occasionally, there'd be subjective tweaks or enhancements, or user-facing text. I found it was often helpful to tweak this kind of thing manually as a final step, rather than trying to get the AI to generate it. Usually I could fill in what I wanted myself faster than I could figure out how to prompt the assistant to produce it. 

By following this structured, iterative cycle with clear, detailed guidance, the AI-generated integration would rapidly evolve from a rough initial draft to polished, production-ready code in minimal time.

A Qualitative Shift in How I Code

One thing that surprised me as I integrated AI into my workflow over the past year was how radically it changed my approach to coding projects. Previously, I often relied heavily on a more improvisational style. I would start with only a vague conception of what I wanted to build, using the act of writing code itself as a way to think through and clarify the details as I went. Typing slowly gave me the space and time to refine my ideas and experiment incrementally.

But AI doesn't work like that. With AI, clarity isn't just beneficial; it's absolutely essential. If you don't start out with a crystal-clear understanding of what you want, you can't formulate the precise, detailed prompts AI needs to generate usable code. Without that precision, the initial output is often too far off-base to be quickly corrected.

Consequently, programming with AI becomes intensely frontloaded. Rather than figuring things out as you type, the initial stages of research, conceptualization, and careful planning are now critical. Once you've nailed that initial plan, the actual act of coding takes very little time. Likewise, iteration and bug fixing become swift and largely automated, drastically compressing the cycle of development from concept to working prototype.

This new approach changes what it takes to be a successful developer. Creativity and firsthand knowledge of the problem space become far more valuable than deep expertise in any specific programming language. In many ways, this is ideal for front-end developers. We're typically deeply connected to user experiences and have extensive insight into user desires, behaviors, and common stumbling blocks. Now, we can bring that user-focused understanding to a broader range of development tasks that previously might have been outside our expertise.

I genuinely believe this approach will lead to better products. Instead of getting bogged down by extensive upfront coding efforts or stuck iterating on hypothetical product specifications, we can quickly build and ship actual prototypes. Real-world feedback from live users can then inform rapid, iterative improvements in near real-time. This agile approach means our products are not just more responsive to user needs but also evolve far more quickly.

In short, coding with AI assistance isn't just about working faster—it's about coding smarter, more creatively, and ultimately delivering better products.