What is Vibe Coding?
With the influx of AI a new concept is born -vibe coding. Google defines "Vibe Coding" as:
a software development workflow where you describe the goal of your app in plain language, and let artificial intelligence handle the technical implementation. You shift from writing code line-by-line to guiding the AI, testing its output, and refining the "vibe" of the project until it works.
So what does that mean in plain English? You use real world words to tell the code what you want it to do and it gets done. Your the one with the vision the AI tool is the one with the development skill. In the simplest definition - you code via prompts making the development much easier.
Yes, vibe coding makes development tasks a LOT easier, but be forewarned every rose has thorns. The thorns are that AI can make mistakes, and when fixing one item can break others. As long as you are aware you can adapt and overcome these thorns. This becomes even easier when using a full AI IDE like Kiro.
Meet Kiro: The AI IDE
Kiro isn’t just another code editor with an AI chat box glued to the sidebar. It splits your workflow into two distinct styles: Vibe Sessions - for fast, conversational prototyping and quick questions and Spec Sessions - where the AI generates structured implementation plans and tests before writing code so your app doesn’t break. It doesn't make changes until you approve them so you are still in the driver's seat.
As a scripter (I don't think of myself as a full developer), the main benefit of using Vibe Coding tools, like Kiro, is speed to market. I share a prompt later below that produced production ready code in about 10 minutes. Yes, there were tweaks/changes that had to be made to make it 100% but all in all I was done the entire script, had it tested, and was using it in about 30 minutes. While everything written in the PowerShell was within my wheelhouse it would have taken me far longer than 30 minutes to get it all coded/tested.
If you're ready to move past basic prompting and see what agentic engineering actually looks like, here is exactly how to get it running on your machine.
Step-by-Step: Downloading and Setting Up Kiro
The Cost of the Vibe: Latest Kiro Pricing Models
Like most AI models, Kiro runs on a credit system. Every prompt you send, spec you generate, or test the agent runs consumes a fraction of a credit based on how heavy the workload is and which underlying LLM (like Claude Sonnet or Opus) is doing the heavy lifting. Prices range from Free (like my favorite beer) to $200/user/mo. for more of enterprise setting.
The Prompt
Requirements:
1. Input
- Accept input as either:
- a text file containing one certificate name per line, or
- a PowerShell array parameter of certificate names.
- Parameterize the input so the script can be run non-interactively.
- Include clear parameter descriptions and examples.
2. Venafi Query Logic
- For each certificate name in the input list, query Venafi and retrieve:
- Certificate Name
- AppID
- GUID
- Expiration Date
- Days remaining before expiration
- Use the exact certificate name from the input list when searching.
- If multiple matches are found, clearly log that condition and skip sending the email unless there is an exact single match.
- If no match is found, log it and continue processing the rest of the list.
- Do not hard-code credentials. Use an existing authenticated session, API token, or parameterized authentication method.
- Structure the Venafi query logic so it can be easily swapped between VenafiPS and direct REST API if needed.
3. Expiration Calculation
- Calculate the number of days left before expiration based on the certificate expiration date.
- Store that value in a field called DaysLeft.
4. Email Logic
- Send one email per certificate found.
- The email body must use the following exact template, with placeholders replaced by the actual values:
Action Required: Certificate Expiring
Certificate Name: {CertificateName}
AppID: {AppID}
URL: {CertificateUrl}
Description: The {CertificateName} certificate is going to expire in {DaysLeft} days. Visit Venafi resource center to see "How-Tos" and additional information.
- Build CertificateUrl using the certificate GUID in this format:
[Venafi Aperture certificate page](https://certificates.mycorp/aperture/certificate/{GUID})
- Make the email subject parameterized, but default it to:
Action Required: Certificate Expiring - {CertificateName}
- Parameterize:
- To
- Cc
- From
- SMTP server or mail-sending method
5. Logging and Output
- Create a detailed CSV log file with one row per certificate processed.
- Include at minimum these columns:
- InputCertificateName
- MatchedCertificateName
- AppID
- GUID
- ExpirationDate
- DaysLeft
- EmailSent
- Status
- ErrorMessage
- Also create a timestamped transcript or log file for troubleshooting.
- Do not overwrite previous logs; create date-stamped output files.
6. Error Handling
- Use robust try/catch blocks.
- Continue processing the remaining certificates if one certificate fails.
- Clearly log:
- not found
- multiple matches
- Venafi query failures
- email send failures
- Validate required parameters before processing.
7. Script Style
- Make the script modular with functions such as:
- Get-CertificateDetailsFromVenafi
- Get-DaysLeft
- Send-CertificateExpirationEmail
- Write-ResultLog
- Keep it fully runnable and copy/paste ready.
- Do not leave placeholder pseudo-code.
- Include comment-based help at the top.
- Use parameter-driven execution only; do not prompt interactively.
8. Final Deliverable
- Return the complete PowerShell script.
- Include a short usage example showing:
- input from a text file
- sample execution with email parameters
- Ensure all syntax is valid and the script is ready to test immediately.
Important implementation notes:
- Prefer exact certificate name matching where possible.
- If the Venafi result includes certificate distinguished name or additional metadata, only use it if needed to uniquely identify the certificate.
- If AppID is missing, still log the certificate and note that AppID was not returned.
- The script must be suitable for automation and future scheduling.
The Verdict
While the prompt above looks long and complicated (don't worry you can use AI for that too) it is far easier (or in my case quicker) than coding the whole script from scratch. Vibe coding isn't just a fleeting trend—it's a peek into how software will be built moving forward. Tools like Kiro prove that you don't have to sacrifice software engineering rigor just because you want to build at the speed of thought. By mixing casual conversation with firm architecture specs, it keeps you firmly in the director’s chair while your AI agents do the heavy lifting. I chose to highlight Kiro, as it was my first vibe coding toolset. But if Kiro doesn’t quite fit your development style, or if you want to explore different ways to build software at the speed of thought, the vibe coding ecosystem has plenty of choices.
- The AI-First IDEs (For Complete Codebase Control)
If you like working locally, want access to a full suite of extensions, and prefer the AI to act as a highly advanced co-pilot or workspace partner, these are your best bets.
- Cursor: The current heavyweight champion of AI code editors.
It is a direct fork of VS Code, meaning all your favorite themes and extensions port over with zero setup. Its "Composer" and agent modes can index your entire repository, allowing you to ask it to refactor code across dozens of files simultaneously while maintaining architectural consistency - Pricing: Generous free tier; Pro plan starts at $20/month.
- Windsurf: Built by Codeium (and powered by Cognition AI tech), Windsurf is Cursor’s fiercest rival.
Its standout feature is the "Cascade" agent system. While Cursor excels at a conversation you lead, Windsurf’s agents are slightly more autonomous, taking multi-step execution paths to solve complex logic puzzles independently. - Pricing: Free tier available; premium plans start at $15/month.
- Browser-First App Builders (From Prompt to Production)
If you don't want to deal with local environments, Git repositories, package managers, or server configurations, these platforms let you build and deploy entirely in a browser tab.
- Lovable: Perfect for building full-stack web applications, internal tools, and rapid MVPs (Minimum Viable Products).
Lovable works by generating highly polished, visually stunning frontend designs and matching them with structured backend capabilities. It explicitly writes out its implementation plan for you to review before it edits any code. - Pricing: Limited free credits; paid tiers start at $25/month.
- Bolt.new: Running inside a web-based StackBlitz container, Bolt.new is arguably the fastest way to turn a single natural language prompt into a live, shareable URL.
It handles full-stack Node.js environments right in your browser, making it an incredible tool for spinning up lightweight prototypes or testing ideas instantly. - Pricing: Free tier; Pro tier starts at $20 to $25/month.
- Terminal-First Agents (For Advanced Power Users)
If you prefer staying out of graphical interfaces entirely and want a tool that hooks directly into your terminal to manipulate your local codebase, look here.
- Claude Code: Anthropic’s official command-line tool.
It operates directly in your terminal, leveraging an immense 1-million-token context window to swallow massive codebases whole. It handles deep repository research, executes terminal commands, runs tests, and lists out a step-by-step checklist of its plan for your approval before execution. - Pricing: Included with Claude Pro ($20/month) or usage-based via API credits.
