Beyond the Hype: How AI is Actually Transforming Developer Workflows Today

I know, you don't stop seeing tweets, posts, and videos about how AI is changing everything. Some are cataclysmic, predicting our replacement by the next shiny model, while others, more realistically, share what's new and how you can leverage it.

But after all the noise, it can feel too abstract, especially if you aren't actively trying out AI in your day-to-day coding. It's easy to dismiss the hype when you're focused on shipping features and fixing bugs.

The Reality Gap Between AI Hype and Developer Experience

Let's be honest, if you haven't actively experimented with AI coding tools in your daily workflow, the endless stream of tweets and LinkedIn posts probably feels disconnected from your reality. The gap between "AI will replace all developers by next Tuesday" and "I just need to fix this bug before standup" is massive.

I'm deeply immersed in the world of AI, constantly experimenting with different tools and approaches. Even so, I find it challenging to convey to friends and colleagues who haven't taken the plunge just how profoundly AI is already changing our work lives in practical ways. They see the demos and the sales pitches, but those perfect scenarios rarely reflect the messy reality of professional development. That disconnect is precisely why I decided to write this post and document my journey, not the highlight reel of perfect interactions, but the evolving, sometimes frustrating, ultimately transformative process of integrating AI into real-world development work.

The Evolution of an AI-Augmented Workflow

My journey with AI in coding began about a year ago. I took on a complex project I was obsessed with, which became my testing ground. You can read the story about the project and its early learnings here.

So, let's get to the goodies: how did I start using AI, and how has that evolved over the past year?

From Quick Wins to Full Partnership

Initially, my use cases were very specific. I focused on implementing simple UI components or trying to one-shot small, self-contained features. For instance, I implemented a fully functional small paywall blocking my app's features for unsubscribed users in about a minute.

Sure, it wasn't the most complex piece of code. Building it manually, however, would likely have taken me around 30 minutes involving fiddling with state, styling, and logic. Seeing it come together so quickly made it clear this was already a game changer, freeing up valuable time and mental energy for more complex challenges.

Over months, my usage patterns evolved significantly. What started as targeted assistance with isolated components gradually transformed into a comprehensive development partnership.

Building Postr: Prompting an App into Existence

At this point, I had spent months developing a complex app, using AI primarily for minor yet relevant tasks. That's when I decided to shift gears and implement a more straightforward app, one that would not only deliver value using AI but also be almost entirely prompted into existence.

This app is Postr.

The idea behind Postr was simple: empower people outside the AI bubble to train AI Assistants capable of writing social media posts in any desired style. Users could upload screenshots of posts they admire, and the AI would learn the nuances to replicate that style.

The development process for Postr looked like this:

• AI Assistant: Cursor with the Claude Sonnet 3.5 model. In my experience, it outperforms OpenAI models, especially for native iOS codebases.
• Context: Indexing relevant documentation web pages directly into Cursor.
• Guidance: Using a great set of native iOS Cursor rules from Josh Pigford found here.
• Design Input: Screenshots of Figma designs my friend Bruno had created for another project.

After about two months of prompting in my spare time, I had a remarkably polished version of the app ready. Virtually everything, from the core features to the RevenueCat integration, subscription state management, and paywalls, was implemented through prompting.

The MVP launch went surprisingly well. I gained 100 users in the first month, and even after 3 months (despite me abandoning further development), 24 recurring users remained. I decided to halt work on Postr because conversations with those initial users revealed a need for a pivot to truly unlock paid conversion. I'm currently working on that pivot, and you'll hear more about it soon. However, the specific outcomes aren't the main focus here.

Beyond Code: AI as a Lifeline in Hectic Times

The crucial point is the context surrounding the Postr launch. I had just moved to a new country, was leading significant projects at my day job, and my father was undergoing surgery. Life was hectic.

What I'm trying to emphasize is that without AI-assisted coding, Postr simply wouldn't exist. It would have been another exciting idea I tinkered with, maybe integrated a few APIs for, and then inevitably relegated to the side project graveyard. I know many of you can relate to that feeling!

So, let's recap the evidence presented so far. AI enabled me to:

• Save significant time by having components fully implemented in a single shot.
• Code an entire, real-world user-facing application in just two months, dedicating only a few hours each week.
• Implement, polish, and even create design assets, making my apps look presentable with a fraction of the typical design effort.

Still think this is all just hype? Hold my beer.

Tackling New Frontiers: AI for Multiplatform Development

I have more examples. Shortly after launching Postr and gathering user feedback, I began working on a new project to address the insights I'd gained. This new project came with expanded requirements, the most critical being native multiplatform support (iOS and macOS).

Here's the challenge: despite years of iOS development, I had never shipped a macOS app. Bootstrapping a project to support macOS natively, especially using SwiftUI from the ground up (my usual approach involved UIKit with embedded SwiftUI), felt daunting. While not overly complex, setting up authentication, a local database, API communication, and a basic, structured home screen for both platforms represented a substantial amount of tedious work.

Normally, this bootstrap phase would take considerable time. Using AI, I accomplished it in a single day.

My technique involved creating a folder named LLMReferences within the project. I filled this folder with relevant code snippets: examples from my previous projects, code from GitHub repositories I admired for their multiplatform handling, and even source code from dependencies (since Swift Package Manager dependencies aren't directly indexable by Cursor within the project directory).

Below is one of the prompts I used to get the multiplatform structure working:

And here's a visual comparison: the original ComposerScreen.swift from an iOS reference versus the basic HomeView.swift generated for the macOS target after the prompt:

Again, the result isn't groundbreakingly complex or visually stunning. Yet, within a couple of hours, I had a functional, native multiplatform app bootstrapped according to my preferred best practices, looking decent enough to start iterating on the core features.

Specialists vs. Generalists: Where Does AI Fit In?

There's a long-standing, sometimes heated discussion in the software development community: should you laser-focus on becoming a deep specialist or cultivate a broader skillset as a generalist? I've seen passionate arguments on both sides throughout my career. Honestly, I never strongly picked a side, my philosophy has always been that if you work hard and deliver value, there's a place for you.

However, I always leaned towards the specialist path. An old friend, also an iOS developer, used to say there are so many APIs within the iOS SDK alone that we probably couldn't master it all even after ten dedicated years, especially since it's constantly evolving. That line of thought resonated with me. I felt I could provide more value to clients and employers by deeply specializing, and that's the path I took.

It worked incredibly well, and I'm proud of where that dedication led me. But after about ten years, a subtle feeling started creeping in, a kind of professional FOMO. "What if I had learned more about backend development or modern frontend web technologies?" So much exciting innovation was happening elsewhere, and I felt like I might be missing out.

Exploring the Unknown

Well, that FOMO largely evaporated with the rise of AI-assisted coding. Recently, I decided to tackle my first significant web project in a very long time: the very website you might be reading this on right now (https://www.doubleslitapps.com/).

It's a static Next.js site using MDX for the blog. Could I have built this before AI tools became prevalent? Technically, yes. I'd even considered it many times. But I knew achieving the level of polish it has now would have taken far longer than the few focused hours AI assistance allowed. That knowledge was a barrier, I simply hadn't done it before because the time investment seemed too high compared to the potential return.

My time outside of my day job is limited, just like yours probably is. I have to be deliberate about what I choose to learn or experiment with. Building a static blog website, while useful, wouldn't typically have topped my priority list unless I could create something high-quality very quickly. And that is one of the biggest powers of AI: it lowers the activation energy, enabling you to actually do the things you previously only thought about.

Knowledge Momentum Keeper

AI isn't just an enabler, it's also a fantastic momentum partner. The feeling is surprisingly similar to having a co-founder when I was running a startup. You see the value accumulating with each step, which motivates you to push further.

After shipping this Next.js site, I thought: why not offload the potentially long-running AI calls in my native app to a simple backend? It shouldn't be too complicated, right?

And indeed, it wasn't. Over the next weekend, I managed to:

• Design and implement a secure file upload system using a private Cloudflare R2 bucket.
• Set up a workflow involving a queue of workers that could: validate a user's Firebase authentication token, upload the file to the private R2 bucket, generate a signed URL for temporary access, store the relevant information in a Firestore document, and finally trigger an AI worker for post-processing tasks.

Keep in mind, I had practically zero backend implementation experience before this. Accomplishing this in less than 8 hours of focused work felt genuinely impressive to me. Now, my macOS app doesn't force the user to wait for this entire process, it uploads the file quickly, and the status updates happen asynchronously in the background. And importantly, I had a lot of fun taking those first steps into backend development.

So, let's quickly recap how AI has been helping me so far:

• Rapid Component Implementation: Building functional UI elements like paywalls in minutes, not hours.
• Full Application Development: Creating entire, user-facing applications like Postr in spare time over a couple of months, despite personal life challenges.
• Bridging Skill Gaps: Bootstrapping projects in unfamiliar domains, like native macOS development, within a day by leveraging existing code and AI guidance.
• Lowering Activation Energy: Making it feasible to tackle projects (like this website) that previously seemed too time-consuming for the available time outside work.
• Accelerated Learning & Implementation: Enabling rapid development of new systems, like the backend file processing workflow, even without prior experience in that specific area.
• Maintaining Momentum: Providing the quick wins and tangible progress needed to stay motivated and see projects through to completion, similar to the boost from a co-founder.

What if I Don't Code on Weekends?

Okay, maybe coding during evenings or weekends isn't your thing, and that's perfectly fine. The good news is that AI-assisted coding isn't just for side projects or learning new stacks. There are plenty of opportunities to leverage these tools effectively within your regular day job.

Here are some ways I've personally used AI assistance in a professional setting:

• Drafting Documentation and RFCs: Finally get that RFC written that you've been putting off. AI can help structure your thoughts, write clearly, and even generate pseudocode examples to back up your proposal.
• Boosting Test Coverage: Writing unit tests, integration tests, or end-to-end tests can be time-consuming. AI can significantly speed up the process of generating test cases and boilerplate code.
• Rapid Prototyping (POCs): Product teams often have ideas they'd love to see prototyped, but developer bandwidth is limited. AI can make building a functional Proof of Concept feasible in a much shorter timeframe, allowing for quicker validation or iteration.
• Accelerating Feature Work: Yes, you can absolutely use AI for core feature development in complex, existing codebases. Before dismissing it as impossible for your project, consider the tools available. With well-defined project-specific rules (.cursorrules), agentic workflows, integration tools like Model Context Protocol (MCP) connectors (e.g., for Figma designs), and powerful models (like Gemini 2.5 Pro MAX), you might be surprised at the productivity gains and even the quality of the output.

Start small, with self-contained components and grow steadily, you'll see the sky is the limit.

Of course, there's a learning curve involved in effectively using these tools. However, many companies are starting to recognize the potential efficiency gains and are willing to support their developers in learning. If your organization isn't yet aware of these possibilities, perhaps sharing this post could help them see past the hype and understand the practical benefits.

Bonus: Shoot Your Shot at Marketing

As you get more comfortable integrating AI into your development workflow, you might find it unlocks capabilities in adjacent areas too. Take the header image for this very blog post, for instance. I didn't need to spend time searching for the right stock photo. I created it using OpenAI's image generation model with just a few prompts.

I started by using a thumbnail from a YouTube video by my good friend Lucas Montano as a reference point and iterated from there. Here's a glimpse of the process:

This is just one example, but it highlights how AI can augment skills beyond pure coding, potentially helping with design, marketing assets, and more.

So, what are your experiences? Are you using AI in your daily development? What surprising benefits or challenges have you encountered? I'd love to hear your thoughts and continue the conversation. Find me on Twitter @filipealva and let's discuss!