It Has a Certain ‘Vibe’

In early 2025, the term “vibe coding” emerged from the world of software development. Coined by artificial intelligence (AI) researcher Andrej Karpathy, it describes a new approach to coding: Instead of writing software line-by-line, developers now guide AI tools with natural-language prompts and iterate their way to the desired product.¹

It’s not really programming in the traditional sense, but it has a place in software. It is important to actuaries and other technical professionals who contribute to software development.

What vibe coding is (and isn’t), and why it matters now

Is: Prompt-and-iterate creation where AI writes most of the first draft; you validate with domain knowledge and/or refined follow-up prompting, “golden” test sets and quick comparisons to trusted methods.

Isn’t: Blindly shipping AI-generated code, or code you merely feel is right.

Ever since PCs have existed, actuaries have developed personal applications, usually using Excel, to address their immediate needs. These quickly produced applications get the job done but sometimes frustrate developers because they lack the controls, documentation and programming efficiency needed for production-quality software. This is especially true if these applications become critical to operations or need to be handed over to others for use or maintenance.

Large language models (LLMs) have reached a stage in software development where they can generate efficient code from natural language prompts. This ability helps bridge the gap between personal applications and production-quality software; although they are not capable of replacing subject matter expertise or the rigor of production development, they occupy a middle ground, as we will explain later in this article.

Recent advances in LLMs specifically targeting code generation, their respective reduction in pricing, the bigger “context” sizes supported (i.e., the size of input and output limits measured in “tokens”/words)—and the ability to self-host or customize them—have led to wider adoption, with more real-life applications now being more practical and cost-effective.

You only need to look at the GitHub benchmark ranker EvalPlus Leaderboard to assess the code-generation abilities of LLMs and AI coders. It ranks models based on their performance across enhanced benchmarks such as HumanEval+, MBPP+ and EvalPerf. These benchmarks help determine how well models generate accurate and efficient code under stricter testing conditions.

The leaderboard shows how models perform before and after applying EvalPlus tests. Proprietary vendors score a respectable 80% to 85%, while open-source LLMs are narrowing the gap. Examples of those evaluated include (but are not limited to): Gemini 2.5 Pro (Google/proprietary), Claude 3.5 Sonnet (Anthropic/proprietary), GPT-4o (OpenAI/proprietary), Grok-4 (xAI/proprietary) and DeepSeek R1/V3 (DeepSeek AI/open source).

Additionally, as articles have shown, organizations such as Amazon have embraced vibe coding internally, stating that AI-assisted developers are seeing productivity gains. At startup facilitator Y Combinator, nearly 25% of startups in early 2025 were building software with over 95% of code written by AI.²

How it works

At its core, vibe coding relies on natural-language prompting. For example, and in principle, a user could ask: Build me a web app where clients can input their age, income and risk tolerance, and receive a personalized investment recommendation.

From there, the AI generates code that starts a feedback loop of user-testing and prompting. The human’s role becomes one of orchestration: steering the AI, testing the output, identifying flaws and shaping the solution through iteration.

Instead of focusing on syntax and architecture, users think in terms of goals, constraints and user experience.

However, it isn’t that simple; the code generated often contains bugs, and it isn’t a subject matter expert in the same way an actuary is. So, the prompt may need to be more specific or require iterations, and the code should be reviewed by a professional developer. An integral part of vibe coding is also the follow-up prompts, which can focus on debugging, refinement, explainability and performance tuning.

For example, you can paste any error messages directly into your LLM and ask: I get this error on this snippet, where my function is defined as per the attached text file. You can also ask for advice on scaling your application on the cloud: I want to deploy my program on AWS, so write me a template infrastructure and give me detailed step-by-step instructions on how to deploy, along with any prerequisites.

Last, as LLMs use your conversation history to predict the next responses, this fills up the “context window” of the LLM, which is not unlimited, as is the “output token” window (i.e., the size limit of the generated text), either. This means that LLMs can perform better with smaller bite-sized tasks. For example, focusing on a template solution with the main parts illustrating the structure can be more productive and accurate than requesting the end-to-end with all details filled in. So, it is better to ask: Show me the recommended changes to my code only, rather than Regenerate my code with the changes.

Opportunities for actuaries

We believe vibe coding could benefit actuaries by potentially improving current workflows, accelerating analysis and converting legacy systems by reducing the technical knowledge barrier that could make such transformations impractical or expensive. Here are three examples:

1. Improving workflow for development.Actuaries often experiment using spreadsheets; this approach is efficient and allows actuaries to work independently to flesh out ideas. But the drawback comes when we want to share these applications, move them to production or scale them for larger datasets. They often lack documentation and are inefficient and difficult to maintain in their prototype format.In this case, think of vibe coding as the missing footbridge between spreadsheets and production systems: spreadsheets > vibe prototypes > engineered apps. You still need engineering for performance, security and scale.To get started, you can also use vibe coding to lift repeatable workbook logic into scripts or tiny APIs so teammates can run the same steps reliably and with and attendant audit.You may also wrap prototypes with the minimum guardrails: config, logging of inputs/assumptions and a tiny test harness. These are shareable and auditable without exposing process detail.

   The pattern is to start small, get a working slice, validate against a trusted result, then decide if it deserves engineering time.

   Real-world example: Raghav Jindal transformed actuarial workflows that once consumed entire afternoons in sprawling Excel workbooks into software products that delivered results in minutes. What used to be limited to a single stress test could now scale seamlessly across dozens of scenarios, whether in ALM, pricing or portfolio analytics. The leap wasn’t just about speed but about unlocking a level of insight and scale that spreadsheets alone could never handle. With vibe coding, if you can imagine the calculation, you’re already a third of the way to building a product that potentially changes how your whole team works.

2. Accelerating analysis.Data preparation and validation helpers can turn raw operational files into analysis-ready tables with basic schema checks, type coercion and “does this look sane?” assertions; fast bridges between source data and your next step.Actuarial teams often need dashboards, custom calculators or scenario simulation interfaces. An actuary with minimal programming experience can prototype small calculators and charts to pressure-test business rules and assumptions, iterate with stakeholders and even deploy them via cloud-based platforms.Real-world example: Chris Martis’ company, Green 13 Solutions, uses vibe coding to accelerate system conversions by translating abstract, unstructured textual inputs (i.e., natural language prompting or insurance product specification/marketing documents) to their Iris-C platform noting, “anything that isn’t bespoke can be accelerated with vibe coding.” Green 13 Solutions uses vibe coding to accelerate system conversions by translating abstract, unstructured textual inputs to their Iris-C platform noting, “anything that isn’t bespoke can be accelerated with vibe coding.”
3. System explanation and testing.Many legacy systems lack documentation and are written in languages, such as COBOL, that lack support and can be difficult to find developers for. Vibe coding can be used to explain and convert legacy code; it can also be used to develop test cases using an application, such as Excel, that the subject matter experts might be more familiar with.But be aware: If the software is proprietary and you don’t have contractual ownership rights to it, reimplementing or converting it (whether manually or with AI) by using elements of that platform as inputs could risk copyright infringement, as we understand it.Real-world example: Kevin Pledge needed to reproduce a unique algorithm from a client’s administrative system to reproduce in their RiskDX platform. After several attempts to reproduce it from descriptions provided, we were sent the source code. Within minutes, we were able to generate an accurate description of the code, build a test pack in Excel and generate a sample function in a modern language.

Risks and limitations

Despite its promise, vibe coding, as it is now, isn’t a silver bullet. AI-generated code can contain hidden bugs, inefficient logic or poor architectural design. It can be hard to maintain, hard to audit and risky to scale if unchecked—although LLMs are increasingly getting better at reviewing, maintaining and documenting code.

For actuaries, the biggest risk we see may be false confidence. Because vibe-coded tools can “look right,” there’s a temptation to trust them too soon without adequate “human-in-the-loop” safeguards.

Ethical and governance concerns arise: Who is responsible for AI-generated code? Can it be trusted in compliance-heavy applications? How do we ensure traceability and transparency? These answers will depend on the individual application; we recommend assigning a human owner, reviewer and tester, even for internal tools.

Finally, vibe coding can also introduce significant software supply chain security risks, which have been exploited in the real world. When AI tools generate code, they can hallucinate imports or recommend packages from untrusted or compromised sources. This makes it easier for malicious actors to exploit techniques like “typosquatting” and “slopsquatting” (AI hallucination exploitation), slipping harmful dependencies into projects without the developer’s knowledge. Such vulnerabilities can act as hidden backdoors, enabling data theft, unauthorized access, or broader system compromise.³

Software expert Simon Willison put it bluntly: “If you understand the code well enough to review it, it’s not vibe coding anymore. You’re just programming the slow way.”

A lightweight vibe-to-production playbook

Prototype (you + AI)

Describe inputs, outputs, and one tiny test case. Ask for an end-to-end script or micro-app. Get it running – even if it’s ugly.

Refine (you)

Ask “why” until the code makes sense. Add three things before anyone else touches it: 1) sanity check for shape/ranges; 2) simple logging (inputs, assumptions, timestamp); and 3) a “golden” comparison vs. your spreadsheet/trusted calc (the 45° X=Y graph is a pretty picture).

Review (you + dev/IT)

Request a quick code review for structure/perf/security; add 3–5 unit tests; pin dependencies. Take refactor suggestions if your team has the cycles; otherwise, mark the limits clearly.

Govern (everyone)

Version it. Label it clearly (Prototype/Non-prod). If shared beyond your team, include a 1-page README and a disclaimer.

Decide

Archive it, keep it as an internal tool or promote it to an engineered service.

Smell test: If you’d be nervous explaining it to Audit, it’s not done.

Conclusion: Use with care

While there has been some speculation by industry leaders about just how far AI could go in automating digital processes, to us, vibe coding signals a shift in how we can think about software development. The shift is from typing every line to directing AI, with clear intent, and then reading every line. You describe the goal, the AI drafts the code, and you guide the process through iteration and testing. The ambition of that goal can be reset with each iteration of LLM releases.

Vibe coding potentially opens a door to faster, cheaper and more accessible software development. This may lead to improved client tools, more agile internal systems, and a greater ability to adapt to regulatory or market changes. It may reduce time-to-insight—quickly transforming an idea into a working demo, tool, or data pipeline; it can then help the actuary or other user decide what’s worth pursuing further. When used effectively, it could enhance actuarial expertise through faster prototypes, better conversations and fewer moments like “we’ll get back to you next quarter.”

As vibe coding reshapes the boundaries of software creation, we see it not as a replacement for actuarial expertise but as an amplifier of it. We also want to stress the actuary’s role in the ethical use and validation of AI-generated outputs.

With great power comes … a great need for testing. AI can generate functional code in seconds, but ensuring that it’s correct, compliant and robust is still up to us. We suggest that you use it for exploration and internal tools. But be aware of the risks. We have no doubt there will be news stories in the future blaming vibe coding for system errors. Don’t be one of them. Treat anything client-facing or regulatory touching as needing proper software engineering and careful testing.

Statements of fact and opinions expressed herein are those of the individual authors and are not necessarily those of the Society of Actuaries or the respective authors’ employers.

Copyright © 2025 by the Society of Actuaries, Chicago, Illinois.