Jobs & Careers
7 Steps to Mastering Vibe Coding
Image by Author | ChatGPT
Of all the buzzwords to emerge from the recent explosion in artificial intelligence, “vibe coding” might be the most evocative, and the most polarizing. Coined by AI luminary Andrej Karpathy, the term perfectly captures the feeling of a new programming paradigm: one where developers can simply express an idea, a “vibe,” and watch as an AI translates it into functional software. It suggests a future where the friction between concept and creation is smoothed away by intelligent algorithms.
This is a powerful and exciting prospect. For newcomers, it represents an unprecedented low barrier to entry. For seasoned developers, it promises to accelerate prototyping and automate tedious boilerplate code. But what does it mean to master this burgeoning approach? If the vibe is all you need, is there anything left to master?
The truth is, mastering vibe coding isn’t about learning to write lazier prompts. Instead, it’s about evolving from a passive recipient of AI-generated code into a skilled conductor of AI-powered development. It’s a journey from simply “vibing” to strategically collaborating with an incredibly powerful, if sometimes flawed, partner.
This guide outlines, in seven steps, what is needed to transform your use of vibe coding from a fun novelty into a professional superpower.
Step 1: Embrace the “Vibe” as a Starting Point
Before you can master vibe coding, you must first embrace it. The initial, near-magical experience of writing a simple prompt and receiving a working piece of software (should you be so lucky on your first attempt) is the foundation of this entire practice. Don’t discount it or rush past this step; use it as a creative sandbox. Think of a simple web app, a data visualization script, or a short utility script, and prompt your AI of choice to build it. This initial phase is crucial for understanding the raw potential and the inherent limitations of the technology.
In this step, your goal is to get a feel for what works and what doesn’t. You will quickly discover that broad, vague prompts like “build me a social media site” will fail spectacularly. However, a more contained prompt like “create a Python Flask app with a single page that has a text box and a button; when the button is clicked, display the text in all caps below it” will have a much better chance of succeeding. This experimentation phase teaches you the art of the possible and helps you build an intuition for the scale and specificity that today’s AI models can handle effectively. Treat this as your prototyping phase, a way to get from zero to one with unprecedented speed.
You may also want to check out this overview of vibe coding for more preliminary information.
Step 2: Cultivate Prompt Engineering as a Discipline
Once you’ve moved past the initial novelty, the next step toward mastery is to treat prompt creation not as a casual “vibe,” but as a deliberate engineering discipline. The quality of your output is (at least, theoretically) directly proportional to the quality of your input. A master of AI-assisted development understands that a well-crafted prompt is like a detailed spec sheet provided to a junior developer. It needs to be clear, specific, and unambiguous.
This means moving beyond single-sentence commands. Start structuring your prompts with distinct sections: define the objective, list the core requirements, specify the technologies and libraries to be used, and provide examples of input and desired output. For instance, instead of “write a function to clean data,” a more disciplined prompt would be as follows:
Write a Python function using the Pandas library called `clean_dataframe`. It should accept a DataFrame as input. The function must perform the following actions in order:
1. Drop any rows with more than two missing values.
2. For the ‘age’ column, fill any remaining missing values with the median age.
3. For the ‘category’ column, fill any missing values with the string ‘unknown’.
4. Return the cleaned DataFrame.
This level of detail transforms the AI from a guesser into a guided tool.
An approach to requirements definition for vibe coding is using a language model to help produce a production requirements document (PRD). This PRD is essentially a fleshed-out version of what is suggested in the above prompt, and if you are familiar with software engineering or product management then you are probably already familiar with a PRD.
Step 3: Shift From Generation to Conversation
A common mistake is to treat vibe coding as a single, monolithic transaction: one prompt, one final block of code. Mastery requires a fundamental shift in this mindset—from generation to conversation. Your AI coding partner is not an oracle; it’s an interactive tool. The most effective workflow is iterative and incremental, breaking a large problem down into a series of smaller, manageable dialogues. Instead of asking the AI to build an entire application at once, guide it through the process.
For example, you could start by asking it to generate the project scaffolding and directory structure. Next, prompt it to write the boilerplate code for the main entry point. Then, move on to generating individual functions, one at a time. After it generates a function, ask it to write unit tests for that specific function. This conversational approach not only yields better, more accurate code but also makes the process far more manageable. It allows you to inspect, verify, and correct the AI’s output at each stage, ensuring the project stays on track and aligns with your vision.
Remember: you don’t just want a model to generate code for you that is essentially a black box. If you make it an interactive process as outlined above, you will have a much better understanding of the code, how it works, and where to look if and when something goes wrong. Lacking these insights, what good is having a chunk of AI-generated code?
Step 4: Master Verification and Rigorous Testing
The single most critical step in graduating from amateur vibe coder to professional is embracing the mantra: “Don’t trust, verify.” AI-generated code, especially from a simple vibe, is notoriously prone to subtle bugs, security vulnerabilities, and “hallucinated” logic that looks plausible but is fundamentally incorrect. Accepting and running code without fully understanding and testing it is a recipe for technical debt and potential disaster.
Mastery in this context means your role as a developer shifts heavily toward that of a quality assurance expert. The AI can generate code with incredible speed, but you are the ultimate gatekeeper of quality. This involves more than just running the code to see if it throws an error. It means reading every line to understand its logic. It means writing your own comprehensive suite of unit tests, integration tests, and end-to-end tests to validate its behavior under various conditions. Your value is no longer just in writing code, but in guaranteeing the correctness, security, and robustness of the code the AI produces.
From this point forward, if using AI-generated code and the tools that enable its generation, you are managing a junior developer, or a team of junior devs. Treat the entire vibe coding process as such.
Step 5: Learn to “Speak” the Code You Vibe
You cannot effectively verify what you cannot understand. While vibe coding opens the door for non-programmers, true mastery requires you to learn the language the AI is speaking. This doesn’t mean you have to be able to write every algorithm from scratch, but you must develop the ability to read and comprehend the code the AI generates. This is perhaps the most significant departure from the casual definition of vibe coding.
Use the AI’s output as a learning tool. When it generates code using a library or a syntax pattern you’re unfamiliar with, don’t just accept it. Ask the AI to explain that specific part of the code. Look up the documentation for the functions it used. This process creates a powerful feedback loop: the AI helps you produce code, and the code it produces helps you become a better programmer. Over time, this closes the gap between your intent and your understanding, allowing you to debug, refactor, and optimize the generated code with confidence. You will also be improving your interaction skills for your next vibe coding project.
Step 6: Integrate AI into a Professional Toolchain
Vibe coding in a web-based chat interface is one thing; professional software development is another. Mastering this skill means integrating AI assistance seamlessly into your existing, robust toolchain. Modern development relies on a suite of tools for version control, dependency management, containerization, and continuous integration. An effective AI-assisted workflow must complement, not bypass, these systems. In fact, some of these tools are now more important than ever.
This means using AI tools directly within your integrated development environment (IDE) — whether GitHub Copilot in VS Code, Gemini in Void, or some other stack entirely — where it can provide context-aware suggestions. It means asking your AI to generate a Dockerfile for your new application or a docker-compose.yml
file for your multi-service architecture. You can prompt it to write Git commit messages that follow conventional standards or generate documentation in markdown format for your project’s README file. By embedding the AI into your professional environment, it ceases to be a novelty generator and becomes a powerful, integrated productivity multiplier. In this way, you will quickly learn when to and when not to use these tools and in what situations, which will save you further time and make you even more productive in the long run.
Step 7: Develop Architectural Vision and Strategic Oversight
This is the final and most crucial step. An AI can write a function, a class, or even a small application. What it cannot do, at least not yet, is possess true architectural vision. It doesn’t understand the long-term trade-offs between different system designs. It doesn’t grasp the subtle business requirements that dictate why a system should be scalable, maintainable, or highly secure. This is where the human master provides the most value.
Your role transcends that of a coder to become that of an architect and a strategist. You are the one who designs the high-level system, defines the microservices, plans the database schema, and establishes the security protocols. You provide the grand vision, and you use the AI as a hyper-efficient tool to implement the well-defined components of that vision. The AI can build the bricks with astonishing speed, but you are the one who designs the cathedral. This strategic oversight is what separates a simple coder from a true engineer and ensures that the final product is not just functional, but also robust, scalable, and built to last.
Conclusion
The journey to mastering vibe coding is, in essence, a journey of mastering a new form of collaboration. It begins with the simple, creative spark of translating a “vibe” into reality and progresses through discipline, verification, and deep understanding. Ultimately, it culminates in a strategic partnership where the human provides the vision and the AI provides the velocity.
The rise of vibe coding doesn’t signal the end of the programmer. Rather, it signals an evolution of the programmer’s roll, away from the minutiae of syntax and toward the more critical domains of architecture, quality assurance, and strategic design. By following these seven steps, you can ensure that you are not replaced by this new wave of technology, but are instead empowered by it, becoming a more effective and valuable developer in the age of artificial intelligence.
Matthew Mayo (@mattmayo13) holds a master’s degree in computer science and a graduate diploma in data mining. As managing editor of KDnuggets & Statology, and contributing editor at Machine Learning Mastery, Matthew aims to make complex data science concepts accessible. His professional interests include natural language processing, language models, machine learning algorithms, and exploring emerging AI. He is driven by a mission to democratize knowledge in the data science community. Matthew has been coding since he was 6 years old.
Jobs & Careers
Gnani.ai Unveils Inya.ai, No-Code Agentic AI Platform for Voice and Chat Agents in 10+ Indic Languages
Gnani.ai has launched Inya.ai, a no-code Agentic AI platform designed to help developers and enterprises deploy intelligent voice and chat agents across customer-facing workflows, without writing a single line of code.
The platform is aimed at revenue-critical functions such as lead qualification, payment nudges, abandoned cart recovery, contextual upselling, and multilingual follow-ups. It supports personalised, emotionally intelligent conversations at scale while maintaining contextual memory across sessions.
To encourage early adoption, Inya.ai is offering $10,000 in free credits to the first 1,000 sign-ups.
“Inya’s multi-agent orchestration capability, allows businesses to create agents for different teams that can communicate, collaborate, and operate cohesively,” said Ganesh Gopalan, co-founder & CEO, Gnani.ai.
With support for voice, chat, SMS, and WhatsApp, Inya.ai is built on the back of Gnani.ai’s eight years of domain expertise in sectors like BFSI, retail, telecom, automotive, and consumer durables. Its multilingual capabilities and enterprise-friendly integration make it adaptable for diverse business needs.
According to the website, companies like IDFC First Bank, P&G, HDFC Bank, and a few others are already testing and deploying this in their work.
“It is open, developer-friendly, voice-first, and built for seamless enterprise integration,” said Ananth Nagaraj, Co-founder & CTO, Gnani.ai.
Gnani.ai’s momentum also includes its selection under the IndiaAI Mission, where the company is developing India’s first voice-focused LLM with 14 billion parameters covering over 40 languages, including more than 15 Indian languages.
Jobs & Careers
Bengaluru Developer Builds ‘Mission Office’ iPhone Game with Potholes and Cows Using ChatGPT

A Bengaluru-based software developer has launched an iPhone game that captures the daily chaos of commuting in the city with the help of AI. Titled Mission Office, the game was created by Harin Nitisvaar using ChatGPT to generate assets, with final edits done in Photoshop.
Built using SwiftUI in Xcode, the game is now available for download on the iOS App Store.
Drawing from his own rides to work on an Ather electric scooter, Nitisvaar, who currently works at Zepto and formerly at Swiggy and Dunzo, designed the game to simulate the challenges faced by Bengaluru commuters.
Players dodge potholes, barricades, and cows, aiming to reach their office in one piece. Familiar city landmarks add to the immersive, cartoon-style gameplay.
“Currently, the player image is AI-generated, and I can even create your avatar driving your favorite vehicle,” Nitisvaar replied to a post asking if players can customise the vehicle to other EVs like Ultraviolette, Ola, or Chetak.
A version 2.0 is in the works, which will add traffic jams and urban floods to further simulate the Bengaluru commute.
The game’s clever integration of real-world elements and its humorous tone have struck a chord on social media. Users on X (formerly Twitter) have praised its relatability, with some suggesting new features like auto-rickshaws and regional language dialogues.
Nitisvaar’s approach stands out for its low-cost development process powered by AI tools, showing how generative models can help solo developers create visually rich games.
While the game is available only on iOS for now, there’s no word yet on an Android release.
Jobs & Careers
Building Modern Data Lakehouses on Google Cloud with Apache Iceberg and Apache Spark
Sponsored Content
The landscape of big data analytics is constantly evolving, with organizations seeking more flexible, scalable, and cost-effective ways to manage and analyze vast amounts of data. This pursuit has led to the rise of the data lakehouse paradigm, which combines the low-cost storage and flexibility of data lakes with the data management capabilities and transactional consistency of data warehouses. At the heart of this revolution are open table formats like Apache Iceberg and powerful processing engines like Apache Spark, all empowered by the robust infrastructure of Google Cloud.
The Rise of Apache Iceberg: A Game-Changer for Data Lakes
For years, data lakes, typically built on cloud object storage like Google Cloud Storage (GCS), offered unparalleled scalability and cost efficiency. However, they often lacked the crucial features found in traditional data warehouses, such as transactional consistency, schema evolution, and performance optimizations for analytical queries. This is where Apache Iceberg shines.
Apache Iceberg is an open table format designed to address these limitations. It sits on top of your data files (like Parquet, ORC, or Avro) in cloud storage, providing a layer of metadata that transforms a collection of files into a high-performance, SQL-like table. Here’s what makes Iceberg so powerful:
- ACID Compliance: Iceberg brings Atomicity, Consistency, Isolation, and Durability (ACID) properties to your data lake. This means that data writes are transactional, ensuring data integrity even with concurrent operations. No more partial writes or inconsistent reads.
- Schema Evolution: One of the biggest pain points in traditional data lakes is managing schema changes. Iceberg handles schema evolution seamlessly, allowing you to add, drop, rename, or reorder columns without rewriting the underlying data. This is critical for agile data development.
- Hidden Partitioning: Iceberg intelligently manages partitioning, abstracting away the physical layout of your data. Users no longer need to know the partitioning scheme to write efficient queries, and you can evolve your partitioning strategy over time without data migrations.
- Time Travel and Rollback: Iceberg maintains a complete history of table snapshots. This enables “time travel” queries, allowing you to query data as it existed at any point in the past. It also provides rollback capabilities, letting you revert a table to a previous good state, invaluable for debugging and data recovery.
- Performance Optimizations: Iceberg’s rich metadata allows query engines to prune irrelevant data files and partitions efficiently, significantly accelerating query execution. It avoids costly file listing operations, directly jumping to the relevant data based on its metadata.
By providing these data warehouse-like features on top of a data lake, Apache Iceberg enables the creation of a true “data lakehouse,” offering the best of both worlds: the flexibility and cost-effectiveness of cloud storage combined with the reliability and performance of structured tables.
Google Cloud’s BigLake tables for Apache Iceberg in BigQuery offers a fully-managed table experience similar to standard BigQuery tables, but all of the data is stored in customer-owned storage buckets. Support features include:
- Table mutations via GoogleSQL data manipulation language (DML)
- Unified batch and high throughput streaming using the Storage Write API through BigLake connectors such as Spark
- Iceberg V2 snapshot export and automatic refresh on each table mutation
- Schema evolution to update column metadata
- Automatic storage optimization
- Time travel for historical data access
- Column-level security and data masking
Here’s an example of how to create an empty BigLake Iceberg table using GoogleSQL:
SQL
CREATE TABLE PROJECT_ID.DATASET_ID.my_iceberg_table (
name STRING,
id INT64
)
WITH CONNECTION PROJECT_ID.REGION.CONNECTION_ID
OPTIONS (
file_format="PARQUET"
table_format="ICEBERG"
storage_uri = 'gs://BUCKET/PATH');
You can then import data into the data using LOAD INTO
to import data from a file or INSERT INTO
from another table.
SQL
# Load from file
LOAD DATA INTO PROJECT_ID.DATASET_ID.my_iceberg_table
FROM FILES (
uris=['gs://bucket/path/to/data'],
format="PARQUET");
# Load from table
INSERT INTO PROJECT_ID.DATASET_ID.my_iceberg_table
SELECT name, id
FROM PROJECT_ID.DATASET_ID.source_table
In addition to a fully-managed offering, Apache Iceberg is also supported as a read-external table in BigQuery. Use this to point to an existing path with data files.
SQL
CREATE OR REPLACE EXTERNAL TABLE PROJECT_ID.DATASET_ID.my_external_iceberg_table
WITH CONNECTION PROJECT_ID.REGION.CONNECTION_ID
OPTIONS (
format="ICEBERG",
uris =
['gs://BUCKET/PATH/TO/DATA'],
require_partition_filter = FALSE);
Apache Spark: The Engine for Data Lakehouse Analytics
While Apache Iceberg provides the structure and management for your data lakehouse, Apache Spark is the processing engine that brings it to life. Spark is a powerful open-source, distributed processing system renowned for its speed, versatility, and ability to handle diverse big data workloads. Spark’s in-memory processing, robust ecosystem of tools including ML and SQL-based processing, and deep Iceberg support make it an excellent choice.
Apache Spark is deeply integrated into the Google Cloud ecosystem. Benefits of using Apache Spark on Google Cloud include:
- Access to a true serverless Spark experience without cluster management using Google Cloud Serverless for Apache Spark.
- Fully managed Spark experience with flexible cluster configuration and management via Dataproc.
- Accelerate Spark jobs using the new Lightning Engine for Apache Spark preview feature.
- Configure your runtime with GPUs and drivers preinstalled.
- Run AI/ML jobs using a robust set of libraries available by default in Spark runtimes, including XGBoost, PyTorch and Transformers.
- Write PySpark code directly inside BigQuery Studio via Colab Enterprise notebooks along with Gemini-powered PySpark code generation.
- Easily connect to your data in BigQuery native tables, BigLake Iceberg tables, external tables and GCS
- Integration with Vertex AI for end-to-end MLOps
Iceberg + Spark: Better Together
Together, Iceberg and Spark form a potent combination for building performant and reliable data lakehouses. Spark can leverage Iceberg’s metadata to optimize query plans, perform efficient data pruning, and ensure transactional consistency across your data lake.
Your Iceberg tables and BigQuery native tables are accessible via BigLake metastore. This exposes your tables to open source engines with BigQuery compatibility, including Spark.
Python
from pyspark.sql import SparkSession
# Create a spark session
spark = SparkSession.builder \
.appName("BigLake Metastore Iceberg") \
.config("spark.sql.catalog.CATALOG_NAME", "org.apache.iceberg.spark.SparkCatalog") \
.config("spark.sql.catalog.CATALOG_NAME.catalog-impl", "org.apache.iceberg.gcp.bigquery.BigQueryMetastoreCatalog") \
.config("spark.sql.catalog.CATALOG_NAME.gcp_project", "PROJECT_ID") \
.config("spark.sql.catalog.CATALOG_NAME.gcp_location", "LOCATION") \
.config("spark.sql.catalog.CATALOG_NAME.warehouse", "WAREHOUSE_DIRECTORY") \
.getOrCreate()
spark.conf.set("viewsEnabled","true")
# Use the blms_catalog
spark.sql("USE `CATALOG_NAME`;")
spark.sql("USE NAMESPACE DATASET_NAME;")
# Configure spark for temp results
spark.sql("CREATE namespace if not exists MATERIALIZATION_NAMESPACE");
spark.conf.set("materializationDataset","MATERIALIZATION_NAMESPACE")
# List the tables in the dataset
df = spark.sql("SHOW TABLES;")
df.show();
# Query the tables
sql = """SELECT * FROM DATASET_NAME.TABLE_NAME"""
df = spark.read.format("bigquery").load(sql)
df.show()
sql = """SELECT * FROM DATASET_NAME.ICEBERG_TABLE_NAME"""
df = spark.read.format("bigquery").load(sql)
df.show()
sql = """SELECT * FROM DATASET_NAME.READONLY_ICEBERG_TABLE_NAME"""
df = spark.read.format("bigquery").load(sql)
df.show()
Extending the functionality of BigLake metastore is the Iceberg REST catalog (in preview) to access Iceberg data with any data processing engine. Here’s how to connect to it using Spark:
Python
import google.auth
from google.auth.transport.requests import Request
from google.oauth2 import service_account
import pyspark
from pyspark.context import SparkContext
from pyspark.sql import SparkSession
catalog = ""
spark = SparkSession.builder.appName("") \
.config("spark.sql.defaultCatalog", catalog) \
.config(f"spark.sql.catalog.{catalog}", "org.apache.iceberg.spark.SparkCatalog") \
.config(f"spark.sql.catalog.{catalog}.type", "rest") \
.config(f"spark.sql.catalog.{catalog}.uri",
"https://biglake.googleapis.com/iceberg/v1beta/restcatalog") \
.config(f"spark.sql.catalog.{catalog}.warehouse", "gs://") \
.config(f"spark.sql.catalog.{catalog}.token", "") \
.config(f"spark.sql.catalog.{catalog}.oauth2-server-uri", "https://oauth2.googleapis.com/token") \ .config(f"spark.sql.catalog.{catalog}.header.x-goog-user-project", "") \ .config("spark.sql.extensions","org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions") \
.config(f"spark.sql.catalog.{catalog}.io-impl","org.apache.iceberg.hadoop.HadoopFileIO") \ .config(f"spark.sql.catalog.{catalog}.rest-metrics-reporting-enabled", "false") \
.getOrCreate()
Completing the lakehouse
Google Cloud provides a comprehensive suite of services that complement Apache Iceberg and Apache Spark, enabling you to build, manage, and scale your data lakehouse with ease while leveraging many of the open-source technologies you already use:
- Dataplex Universal Catalog: Dataplex Universal Catalog provides a unified data fabric for managing, monitoring, and governing your data across data lakes, data warehouses, and data marts. It integrates with BigLake Metastore, ensuring that governance policies are consistently enforced across your Iceberg tables, and enabling capabilities like semantic search, data lineage, and data quality checks.
- Google Cloud Managed Service for Apache Kafka: Run fully-managed Kafka clusters on Google Cloud, including Kafka Connect. Data streams can be read directly to BigQuery, including to managed Iceberg tables with low latency reads.
- Cloud Composer: A fully managed workflow orchestration service built on Apache Airflow.
- Vertex AI: Use Vertex AI to manage the full end-to-end ML Ops experience. You can also use Vertex AI Workbench for a managed JupyterLab experience to connect to your serverless Spark and Dataproc instances.
Conclusion
The combination of Apache Iceberg and Apache Spark on Google Cloud offers a compelling solution for building modern, high-performance data lakehouses. Iceberg provides the transactional consistency, schema evolution, and performance optimizations that were historically missing from data lakes, while Spark offers a versatile and scalable engine for processing these large datasets.
To learn more, check out our free webinar on July 8th at 11AM PST where we’ll dive deeper into using Apache Spark and supporting tools on Google Cloud.
Author: Brad Miro, Senior Developer Advocate – Google
-
Funding & Business1 week ago
Kayak and Expedia race to build AI travel agents that turn social posts into itineraries
-
Jobs & Careers1 week ago
Mumbai-based Perplexity Alternative Has 60k+ Users Without Funding
-
Mergers & Acquisitions1 week ago
Donald Trump suggests US government review subsidies to Elon Musk’s companies
-
Funding & Business1 week ago
Rethinking Venture Capital’s Talent Pipeline
-
Jobs & Careers1 week ago
Why Agentic AI Isn’t Pure Hype (And What Skeptics Aren’t Seeing Yet)
-
Education1 day ago
9 AI Ethics Scenarios (and What School Librarians Would Do)
-
Jobs & Careers1 week ago
Astrophel Aerospace Raises ₹6.84 Crore to Build Reusable Launch Vehicle
-
Funding & Business5 days ago
Sakana AI’s TreeQuest: Deploy multi-model teams that outperform individual LLMs by 30%
-
Funding & Business1 week ago
From chatbots to collaborators: How AI agents are reshaping enterprise work
-
Education2 days ago
Nursery teachers to get £4,500 to work in disadvantaged areas