Vibe Coding with an Agent and Twilio SMS

September 17, 2025
Written by
Reviewed by

Vibe Coding with an Agent and Twilio SMS

"Vibe coding" is the act of using an AI to write your code for you with very little human input. Many engineers are not just vibe coding with cutting and pasting code, but using an Agent: a coding AI that works independently. Instead of cutting and pasting code into a file, the coding agent can create its own files, running in a folder and creating an entire application architecture with minimal manual input from the developer.

This isn't my first experience with vibe coding. In a pair of previous articles, I was using OpenAI's ChatGPT for vibe coding. The first article in the series explores the definition of vibe coding in more depth and shows a step-by-step example of basic application creation in Python. The second article talks about updating existing Twilio templates with vibe coding.

In this article, I'm doing something a little more ambitious with vibe coding. For the first time, I tried vibe coding using Anthropic's Claude coding agent. I'm also doing a larger project with a web component using Twilio APIs.

Since results may vary when using this method, this article is not really a tutorial. Your outcomes may be different depending on your computer and your setup. At the end of the article I'll share my thoughts about the process, and a link to the code to try out yourself.

Setting up Claude

The first step to coding with Claude Code is to set up Claude on your machine. For someone with limited coding experience setting up the Claude coding environment may be difficult. Claude Code’s set up process assumes that the user is comfortable with the terminal, which is not true of all users.

In the Claude documentation, Anthropic provides a getting started setup for using Claude for the first time. This does make some assumptions about the user. For example, it assumes you have a standard coding environment where you have all the permissions to allow the agent to add files. It also assumes you understand basic things about coding such as file and folder structure, and how to use the command line.

Once Claude is set up, the Quickstart guide explains how to authenticate with Claude Code, and create your first project using the agent. Claude Code runs as a command line only tool. This is a boon to developers who want a lean experience. But this might be intimidating to a non-coder who might prefer a drag-and-drop solution or one that feels a little more beginner-friendly.

Vibe Coding with the Agent

Now that Claude Code is set up, it’s time to come up with a project.

I thought about putting myself in the shoes of a user that didn't know anything about coding from here, but wanted to create an application for their business. I decided to use .NET because of my familiarity with it, and also to see what Claude could really come up with.

This will be an automated SMS project. I added a WhatsApp option to this for easier testing also, since, in some regions, 10DLC registration makes it hard to do automated SMS. I also made some decisions about what kind of product this user would want. They might want a 'dashboard' web interface that they could use to set up automated texting, and that should be as easy as possible for a non coder to use. Putting these design specifications together allowed me to come up with a project that I could instruct Claude to build.

In designing a prompt for an LLM, it is best to be specific about your goals and intentions. The more detail that I can fill in this prompt the better, though I also want to avoid giving extraneous information that doesn't help the agent. I decided it would help to declare for the prompt exactly what the goal of the dashboard would be and who was likely to use it. A few specific word choices will guide the creation of the UI for the web dashboard to make it meaningful for my user.

The first prompt I used was this:

Create a repo to use Twilio APIs in C#. This program should contact opted-in users with automated SMS messages and WhatsApp messages. I want a web facing dashboard where I could type in a message that I want to send via text, and send it to all my users. This is for sending promotional discounts and campaigns.

The dashboard should be easy for a noncoder to use, and the phone numbers of my SMS and WhatsApp users should be stored in a local file.

I've introduced a bit of a security flaw with this setup in using a local file to store users' information, but I wanted to make a quick prototype first. If I were to expand on this application, I'd want to use a secure database and additional tooling for customer privacy. But I wanted to give Claude a reasonable task that it could try locally without using additional APIs and tools other than Twilio.

When I gave Claude this prompt, it began to spin up some files. Claude checked in with me every step of the way.

What is interesting about this is watching Claude's process. Claude gave itself a "todo" list going through the steps of how it would structure my application. As it did the "todos," it checked them off its list, just like a coder focused on the project might do.

Here's an example of what that output looks like from Claude, when it's running in progress:

⏺ Now let's create the user/phone storage system:
⏺ Update Todos
  ⎿  ☒ Initialize a new C# web application                            
     ☒ Add Twilio SDK and other required packages
     ☐ Create a simple user/phone storage system using local files
     ☐ Implement Twilio SMS and WhatsApp message sending functionality
     ☐ Build a simple web dashboard for sending messages
     ☐ Create documentation for using the application
⏺ Let's create the models and storage system for users and their phone
  numbers:
⏺ Write(TwilioMessenger.Core/Models/Contact.cs)

Here, we can see that Claude has already initialized the C# application, and added Twilio SDKs in previous steps. Now it's moving on to creating the user storage system by making a Contact.cs file.

When it was fully done creating the application, Claude was also kind enough to create instructions for how to run this application. It did this by creating a README.md just like you would find in a standard Github repository:

⏺ Now let's create a documentation file to help users understand how to
  use the application:
⏺ Write(README.md)
  ⎿  Wrote 96 lines to README.md                                         
     # Twilio Messenger
     A simple C# application for sending promotional SMS and WhatsApp
     messages to opted-in users.
     ## Features
     - Send promotional messages to users via SMS and WhatsApp
     - Manage contacts in a simple local database
     - User-friendly web dashboard for non-technical users
     - Support for bulk messaging to all contacts or specific groups
     … +86 lines (ctrl+r to expand)
⏺ Update Todos
  ⎿  ☒ Initialize a new C# web application                            
     ☒ Add Twilio SDK and other required packages
     ☒ Create a simple user/phone storage system using local files
     ☒ Implement Twilio SMS and WhatsApp message sending functionality
     ☒ Build a simple web dashboard for sending messages
     ☒ Create documentation for using the application

Then, Claude gave me a helpful prompt back to assist me in getting the application to run for the first time:

⏺ I've created a C# application using Twilio APIs for sending promotional
   SMS and WhatsApp messages to opted-in users. Here's what's included:
  1. A .NET Core web application with a simple dashboard
  2. Twilio SDK integration for SMS and WhatsApp messaging
  3. Contact management system with local file storage (JSON)
  4. User-friendly web interface for non-coders
  5. Comprehensive README with setup and usage instructions
  The application allows you to:
  - Add, edit, and remove contacts
  - View contact stats on the dashboard
  - Send promotional messages to all contacts or specific groups
  - Track message delivery success and failures
  To use the application:
  1. Update the Twilio credentials in appsettings.json
  2. Run the application with dotnet run
  3. Access the web dashboard at localhost:5000

Debugging with an AI Agent

Now I had a structured application completely vibe coded with Claude.

There was just one problem with all this: it didn't actually work. I ran the project as instructed, but no web dashboard showed up at localhost:5000 as Claude said it would. There was a dashboard running on a different port, but when I tried to access that, it errored.

I was worried for a second that maybe my initial instructions for the application were too ambitious. But vibe coding projects may simply not work well the first time, and debugging is an important part of coding. So I simply told Claude that it needed to fix the bugs and try again.

Screen showing debugging suggestions for a crashing ASP.NET Core application using port 5105 instead of 5000.

Claude went to work fixing the crash and tried to see if it could solve the problem with the first attempt at the code. It did all of this with minimal input from me, occasionally asking for permission to change a file.

This time, when I tried running the program that Claude created, it worked! Claude was able to generate a dashboard, connect to Twilio APIs, and send me an automated SMS. All I had to do was connect my Twilio API keys to the project by going into the provided appsettings.json file it already created.

Final Result of Vibe Coding

This is the final result of Claude's work:

Screenshot of a barebones Twilio messenger Dashboard that allows SMS and WhatsApp connections

It's not very fancy, but it's functional!

Click on "manage contacts" to add a contact to the database and specify contact type:

Screenshot of the manage contact page from this vibe coded project

Once contacts are added, the application uses this screen to send a promotional message to those contacts. A drop-down menu was even added so the user can choose can choose to send promotions via SMS, WhatsApp, to all contacts, or to a specific user.

screenshot showing the send promotional message screen in the dashboard.

It really worked! I tested adding my phone number to the database, texting myself on WhatsApp, and I received my test promotional message. Really cool! And all done in .NET with no manual coding.

Checking in on Github

There was one last step that was important to all of this. While Claude generated my application in a format that might be common on Github, it wasn't actually ready to upload to Github. Security was going to be an issue. To get it onto Github where it seemed like it needed to be, it needed a .gitignore file. A .gitignore file tells Github what files should be ignored in your build when it uploads code to the internet. This keeps secure parts of your code safe by not exposing API keys or other sensitive user information.

Though Claude's code otherwise resembled a properly formatted Github repo, Claude didn't provide this .gitignore file initially. If you are vibe coding and going to upload to any open source community, beware. Make sure you are using your best practices to avoid exposing any API keys to the web and posting them to Github.

I prompted Claude to add the necessary file by saying this:

> Can you create a proper gitignore for this?

Here was Claude’s response:

✻ Thinking…
  I need to create a proper .gitignore file for a .NET project. This should include common
   files and directories that should be excluded from version control, such as:
  1. Build artifacts and binaries
  2. User-specific files
  3. IDE-specific files 
  4. Log files
  5. Dependency directories
  6. Sensitive data like the contacts.json
  Let me create a comprehensive .gitignore for this C# Twilio project.

Claude then created the necessary file. This was useful for putting the files on Github, but I also had to make sure that my initial appsettings.json and contacts.json files were sanitized so that a blank version existed on the Github repository. Once all of that was in place, I was able to push the entire project up to Github.

Curious what Claude Code and I created? You can find the entire Github project here.

Final Thoughts

Ultimately, this is a prototype and not a production ready solution. If you were interested in using Claude to vibe code a project, it's a great way to get started, but you'd want to be sure to be careful about security. For a production-ready solution, double-check all your code and make sure a human reviews it before it's used or you might run into security issues. A code review process by another developer might also increase the security and stability of your vibe coded solution.

If I were a non-coder and had no experience with coding, vibe coding with Claude probably isn't where I'd start learning. While the process was smooth and pretty easy, the skill level needed to get Claude pointed in the right direction would assume some familiarity with coding practices. A total novice would have to learn the basics of command line tooling before trying this experience with Claude.

Claude Code's vibe coding process seemed like a pretty good solution for a developer who already has some familiarity with tools like the command line and git. It would be especially useful for creating simple boilerplate tools that might not need any creative or very customized solutions, and doing rote work that relies on well-known architectures.

Do you think you'll give vibe coding with Claude Code a try? You might find this video on live vibe coding with Claude to be useful for another overview of the process. Or check out some of the other articles posted by some of my colleagues at Twilio:

Let's build something amazing!

Amanda Lange is a .NET Engineer of Technical Content. She is here to teach how to create great things using C# and .NET programming. She can be reached at amlange [ at] twilio.com.