<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/"
    xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="http://search.yahoo.com/mrss/" version="2.0">
    <channel>
        
        <title>
            <![CDATA[ vibe coding - freeCodeCamp.org ]]>
        </title>
        <description>
            <![CDATA[ Browse thousands of programming tutorials written by experts. Learn Web Development, Data Science, DevOps, Security, and get developer career advice. ]]>
        </description>
        <link>https://www.freecodecamp.org/news/</link>
        <image>
            <url>https://cdn.freecodecamp.org/universal/favicons/favicon.png</url>
            <title>
                <![CDATA[ vibe coding - freeCodeCamp.org ]]>
            </title>
            <link>https://www.freecodecamp.org/news/</link>
        </image>
        <generator>Eleventy</generator>
        <lastBuildDate>Tue, 17 Nov 2026 21:37:55 +0000</lastBuildDate>
        <atom:link href="https://www.freecodecamp.org/news/tag/vibe-coding/rss.xml" rel="self" type="application/rss+xml" />
        <ttl>60</ttl>
        
            <item>
                <title>
                    <![CDATA[ How to Automate Docker Image Creation for Postgres Using Shell Commands ]]>
                </title>
                <description>
                    <![CDATA[ If you have certain lines of code that repeat over and over again in a project, there's a pretty standard solution for it: using a function. But what about when you have the same project file setup th ]]>
                </description>
                <link>https://www.freecodecamp.org/news/how-to-automate-docker-image-creation-for-postgres-using-shell/</link>
                <guid isPermaLink="false">6aea2aaffbe759481e70cb16</guid>
                
                    <category>
                        <![CDATA[ shell ]]>
                    </category>
                
                    <category>
                        <![CDATA[ shell scripting ]]>
                    </category>
                
                    <category>
                        <![CDATA[ Bash ]]>
                    </category>
                
                    <category>
                        <![CDATA[ docker images ]]>
                    </category>
                
                    <category>
                        <![CDATA[ Docker compose ]]>
                    </category>
                
                    <category>
                        <![CDATA[ postgres ]]>
                    </category>
                
                    <category>
                        <![CDATA[ vibe coding ]]>
                    </category>
                
                    <category>
                        <![CDATA[ automation ]]>
                    </category>
                
                    <category>
                        <![CDATA[ Workflow Automation ]]>
                    </category>
                
                <dc:creator>
                    <![CDATA[ jabo Landry ]]>
                </dc:creator>
                <pubDate>Tue, 03 Nov 2026 18:40:47 +0000</pubDate>
                <media:content url="https://cdn.hashnode.com/uploads/covers/5e1e335a7a1d3fcc59028c64/60aa4c00-42d7-4e36-84b4-89f55b140dca.png" medium="image" />
                <content:encoded>
                    <![CDATA[ <p>If you have certain lines of code that repeat over and over again in a project, there's a pretty standard solution for it: using a function.</p>
<p>But what about when you have the same project file setup that gets repeated over and over? How do you solve that?</p>
<p>Meet bash scripting. Bash scripts are written to execute certain sequences of commands on your machine automatically without you having to do anything. This is known as workflow automation, and that's what I'll be teaching you how to do in this article.</p>
<h2 id="heading-table-of-contents">Table Of Contents</h2>
<ul>
<li><a href="#heading-prerequisites">Prerequisites</a></li>
<li><a href="#heading-what-motivated-this-project">What Motivated This Project?</a></li>
<li><a href="#heading-introduction">Introduction</a></li>
<li><a href="#heading-conditions-in-bash">Conditions in bash</a></li>
<li><a href="#heading-interactive-shell">Interactive Shell</a></li>
<li><a href="#heading-how-to-create-and-write-to-a-file">How to Create and Write to a File</a></li>
<li><a href="#heading-bash-arguments-and-flags">Bash Arguments and Flags</a></li>
<li><a href="#heading-how-to-make-your-scripts-executable-and-available-on-your-pcs-path">How to Make Your Scripts Executable and Available on Your PC's Path</a></li>
<li><a href="#heading-conclusion">Conclusion</a></li>
</ul>
<h2 id="heading-prerequisites">Prerequisites</h2>
<p>To follow along with this article, you should have:</p>
<ul>
<li>Git-bash installed on your machine</li>
<li>Some experience using a terminal or command prompt to run and execute commands (helpful but not required)</li>
<li>Understanding of basic programming concepts (like conditions and loops)</li>
<li>Docker installed on your machine</li>
<li>Basic understanding of Docker concepts (like images and containers)</li>
<li>Experience using Postgres (optional but recommended)</li>
</ul>
<h2 id="heading-what-motivated-this-project">What Motivated This Project?</h2>
<p>I was recently setting up a Docker image for Postgres on a few projects I was working on, and I noticed that I was following the same pattern in creating the images. The only difference was that they had different database credentials and database names.</p>
<p>I also realized that a large portion of today's rapidly developed apps tend to use Supabase as their backend, which can come with resource limits such as database storage, bandwidth, concurrent connections, and API request quotas (depending on the service tier and size of the project). And these issues can be solved by setting up your database.</p>
<p>So I thought, why not make a CLI tool that could automate creating Docker images for Postgres? That's when I learned about writing executable shell commands using bash to create workflow automations.</p>
<p>You can find the full working example used in this guide in this <a href="https://github.com/jabo-arnold-landry/Postgres-docker-image-generator">git-repo</a>.</p>
<h2 id="heading-introduction">Introduction</h2>
<p>Bash is a shell and scripting language used to write and execute commands or scripts that perform operations on a computer, such as creating directories and files, manipulating files, automating tasks, and managing system processes.</p>
<p>In this guide, you'll learn to automate the process of creating a Docker image for a Postgres database so that you don't have to create the image from scratch for each new project.</p>
<h3 id="heading-bash-scripting-file-setup">Bash Scripting File Setup</h3>
<p>To get started, open you preferred text-editor and create a directory or folder there. Then within that directory, create a file with the extension <code>.sh</code>.</p>
<p>At the beginning of a file, type:</p>
<pre><code class="language-shell">#!/bin/bash
</code></pre>
<p><code>#!/bin/bash</code> (known as a "shebang") tells the operating system to run the script using the Bash shell, so the commands inside the file are executed as Bash/terminal commands.</p>
<h2 id="heading-conditions-in-bash">Conditions in bash</h2>
<p>After you've finished creating a script file and adding shebang, let's start by exploring how if statements are used in bash.</p>
<p>The syntax of <code>if</code> looks like this:</p>
<pre><code class="language-shell">if [[ condition ]];
    then
        command to execute
fi
</code></pre>
<p>The <code>if</code> in bash is no different from what you're used to in other programming languages:</p>
<ul>
<li>You use double square braces ([]) to add a condition you're checking against and a semicolon (;).</li>
<li>You use <code>then</code> after the <code>if</code> declaration to specify what should be executed if the condition is true.</li>
<li>You use the <code>fi</code> to close the condition statement.</li>
</ul>
<p>When you're writing the condition inside the square braces, make sure you leave a space before the condition and another one after it (as you can see in the code above). If you omit these spaces, you'll get errors.</p>
<h3 id="heading-working-example">Working Example:</h3>
<p>Since we are automating Postgres database Docker image creation, first check if the file exists and has content. If it does have content, end the script. If not, we'll proceed with the next script.</p>
<pre><code class="language-shell">#!/bin/bash

if [[ -s docker-compose.yml ]];
    then
        echo "The file already exists"
        exit 0
fi

echo "Next command"
</code></pre>
<p>In the if condition, we use the flag <code>-s</code> to check if the file exists and has contents. File flags check file availability and permissions, and include but aren't limited to:</p>
<ul>
<li>-f: used to check if the file exists</li>
<li>-s: used to check if the file exists and has contents</li>
<li>-d: used to check if a directory exists</li>
<li>-r: used to check if a file is readable</li>
<li>-w: used to check if a file is writable</li>
<li>-x: used to check if a file is executable</li>
</ul>
<p>In the script, we're using <code>-s</code> to check if a file named <code>docker-compose.yml</code> exists in the directory where we're executing the command. If it's false, we use the <code>echo</code> keyword to print the text "Next command". If it's true, we print the text "The file already exists".</p>
<p><code>exit</code> acts as a return keyword for bash scripting, 0 is used for success, and 1 is used for failure.</p>
<p>Let's test all this by creating a Docker Compose file and adding some content in the same directory where we're writing the bash script. In your terminal type <code>bash name-of-file.sh</code>, and you should see "The file already exists":</p>
<img src="https://cdn.hashnode.com/uploads/covers/69c7bcff7cf27065100ae8be/14d2b684-5e37-4e70-b6be-05386777fd68.png" alt="output after creating the already existing file using bash" style="display: block;" width="600" height="400" loading="lazy">

<p>But if we delete the content in the file and run the command again, we should see the output saying "Next command":</p>
<img src="https://cdn.hashnode.com/uploads/covers/69c7bcff7cf27065100ae8be/130698ee-7309-4f3e-9eb0-37632b954ded.png" alt="output of a successful file creation in bash" style="display: block;" width="600" height="400" loading="lazy">

<h2 id="heading-interactive-shell">Interactive Shell</h2>
<p>To make an automation dynamic and flexible you will need to receive inputs, take an example of a database name you won't always have the same database name, the name will change based on the project,</p>
<p>you do need to setup away to use a given name of the database when creating a new docker image for that you read inputs using the <code>read</code> keyword.</p>
<p>There are different types of inputs based on the operation. And there are flags that are used to specify which type of input you're expecting, such as:</p>
<ul>
<li>-p: for prompting the user to write a text</li>
<li>-s: used on passwords when you want the user input to stay hidden when writing it in the terminal</li>
<li>-a: used when you're expecting the user to pass in multiple inputs or if you're expecting an array from user.</li>
</ul>
<p>Here's the syntax for reading user input:</p>
<pre><code class="language-shell">read -p 'input_label: ' variable_name
</code></pre>
<h3 id="heading-working-example">Working Example:</h3>
<p>Now let's create scripts to receive user input about the Postgres database image you're going to create.</p>
<pre><code class="language-shell">#!/bin/bash

# database credentials
read -p 'DataBase-name(*): ' db
read -p 'DataBase-user(*): ' user
read -sp 'DataBase-password(*): ' pwd
echo
echo "your database is -&gt; $db with a username of $user and a password of $pwd"
</code></pre>
<p>The script uses <code>-p</code> on the <code>read</code> keyword that prompts a string of text and <code>-sp</code> that prompts the user to enter a string of text that's hidden (because the <code>-s</code> hides what's being typed).</p>
<p>If you don't use the <code>-p</code> option together with <code>-s</code>, you won't be able to display a prompt asking the user to enter a password. With <code>-s</code> alone, the input is hidden, but no prompt is shown unless you print one using <code>echo</code> or <code>printf</code>.</p>
<p>To print or use the input the user has added, use the dollar sign ($) followed with a variable name for the input you're expecting from the user. In the example above, we named the variable for getting the database name <code>db</code>, so we'll use <code>$db</code> when we want to access the name of the database the user has input.</p>
<p>Now if you run the script in the terminal, you should see a sequence of terminal prompts waiting for inputs. Once they're filled, you'll see all the input's values in the terminal:</p>
<img src="https://cdn.hashnode.com/uploads/covers/69c7bcff7cf27065100ae8be/9871cea4-07f0-4626-ba2a-f4ca738e447b.png" alt="output on how to get and display user inputs " style="display: block;" width="600" height="400" loading="lazy">

<h3 id="heading-how-to-validate-and-sanitize-input">How to Validate and Sanitize Input</h3>
<p>You'll also need to validate input before executing anything. This is important because sometimes crucial field might be missing or mistyped. For example, you might forget to input the database name for the image you're trying to create.</p>
<p>When validating input, you'll use one of these flags (among others):</p>
<ul>
<li>-z: checks if a variable value is empty</li>
<li>-n: checks if a variable value is not empty</li>
<li>-lt: checks if a number is less than a given number</li>
<li>-gt: checks if a number is greater than a given number</li>
<li>-eq: checks for equality of two values</li>
</ul>
<p>You can use the <code>-z</code> flag on every input that you need to make sure isn't empty before moving on to the next step:</p>
<pre><code class="language-shell">#!/bin/bash

# database credentials
read -p 'DataBase-name(*): ' db
if [[ -z $db ]]
    then
        echo "The database field cannot be empty!"
        exit 1
fi

read -p 'DataBase-user(*): ' user
if [[ -z $user ]]
    then
        echo "The user field cannot be empty!"
        exit 1
fi

read -sp 'DataBase-password(*): ' pwd
if [[ -z $pwd ]]
    then
        echo "The password field cannot be empty!"
        exit 1
fi
</code></pre>
<p>This script helps you make sure that all critical information about the database is present before proceeding to another input.</p>
<h3 id="heading-default-values">Default Values</h3>
<p>You may want some fields to use default value (for example, the container name of the image, port, or volume of the container). For such scenarios you can use <code>:=</code> to assign a variable default value:</p>
<pre><code class="language-shell">#!/bin/bash

# container information
read -p 'Container-name: ' container_name
read -p 'Container-port(if omitted, the container will use default postgresql default port of 5432): ' port
read -p 'Volume-name: ' vol_name

echo "container-name-&gt; ${container_name:=cont_one}, port-&gt;${port:=5432}, volume_name-&gt;${vol_name:=backend_data}"
</code></pre>
<p>When you run the script and skip all three of those inputs, bash will use the default value(s) you've used as fallbacks.</p>
<img src="https://cdn.hashnode.com/uploads/covers/69c7bcff7cf27065100ae8be/63c5a5df-10f6-4b9e-b3f1-28460b0db3e4.png" alt="Output for setting up a default value on variables" style="display: block;" width="600" height="400" loading="lazy">

<p>But if you pass value for those inputs, bash uses the provided values. For example, supply all three inputs and see the output you get:</p>
<img src="https://cdn.hashnode.com/uploads/covers/69c7bcff7cf27065100ae8be/d62949f4-b87e-448e-b702-393a04ed19ab.png" alt="Receiving user inputs and displaying the recevied input" style="display: block;" width="600" height="400" loading="lazy">

<h2 id="heading-how-to-create-and-write-to-a-file">How to Create and Write to a File</h2>
<p>Now that you know how to create a Docker image for a Postgres database, you need to create a <code>docker-compose.yml</code> file that will be executed when starting and stopping your containers.</p>
<p>In Bash, there are multiple ways of creating a file:</p>
<ul>
<li>First, you can use <code>&gt; filename</code>. This creates a file if it doesn't exist. If it exists, its contents are overwritten (replaced).</li>
<li>There's also <code>&gt;&gt; filename</code>: This appends contents to a file or creates a file if one doesn't exist.</li>
<li>Finally, there's <code>touch filename</code>: This creates a file if it doesn't exist. If the file already exists, its contents are preserved and only the file's timestamps are updated.</li>
</ul>
<h3 id="heading-how-to-use-gt-to-create-and-write-to-a-file">How to Use <code>&gt;</code> to Create and Write to a File</h3>
<p>When you want to create a file and write content to it at the same time, you'll want to use echo in front of <code>&gt;</code> and then add the filename, like this:</p>
<pre><code class="language-shell">#!/bin/bash

echo Hello&gt; test.txt
</code></pre>
<p>This will create a <code>test.txt</code> file with "hello" as content inside.</p>
<h3 id="heading-how-to-use-gtgt-to-append-contents-to-an-existing-file">How to Use <code>&gt;&gt;</code> to Append Contents to an Existing File</h3>
<p>To append contents to an existing file, add the contents before the <code>&gt;&gt;</code> and then follow with the filename you want to append content onto. Let's add Africa after Hello in the <code>test.txt</code> file we created in the previous script.</p>
<pre><code class="language-shell">#!/bin/bash

echo Africa!&gt;&gt; test.txt
</code></pre>
<p>Now test.txt will have Hello and Africa! on the new line.</p>
<p>Using those symbols, let's create a <code>docker-compose.yml</code> file that will hold contents about our Postgres database setup.</p>
<pre><code class="language-shell">#!/bin/bash

&gt; docker-compose.yml
</code></pre>
<p>And just like that you have your docker-compose file created in your directory.</p>
<h3 id="heading-how-to-write-multiple-different-contents-to-a-file">How to Write Multiple Different Contents to a File</h3>
<p>You can also use the <code>cat</code> keyword to write to a file. Typically, <code>cat</code> is used for reading the contents of a file. But when you combine it with <code>&lt;&lt;EOF</code> and the sign for appending contents to a file <code>&gt;&gt;</code> (that we just discussed), you can add multiple contents to a file in the format you want. The syntax looks like this:</p>
<pre><code class="language-shell">
# writing docker compose contents

cat &lt;&lt;EOF&gt;&gt; docker-compose.yml

  # file contents
EOF
</code></pre>
<p>The <code>&lt;&lt;EOF</code> tells bash to write contents to a file until it finds the EOF keyword (end of file). Then you use <code>&gt;&gt; filename</code> to append the contents to the file. With a Docker compose setup it would look like this:</p>
<pre><code class="language-shell">#!/bin/bash

#file creation and writing
 &gt;  docker-compose.yml

cat&lt;&lt;EOF&gt;&gt;docker-compose.yml
 services:
    postgres:
        image: postgres:18-alpine
        container_name: ${container_name:= $db}

        environment:
            POSTGRES_USER: $user
            POSTGRES_PASSWORD: $pwd
            POSTGRES_database: $db

        ports:
            - ${port:=5432}:5432
        volumes:
            - ${vol_name:=database-data}:/var/postgresql

 volumes:
    ${vol_name:=database-data}:

EOF
</code></pre>
<h2 id="heading-bash-arguments-and-flags">Bash Arguments and Flags</h2>
<p>With Bash arguments, you can pass values in the same line while executing a script. To use arguments, add the values while executing the script on the same line, like this:</p>
<pre><code class="language-shell">bash script val1 val2 
</code></pre>
<p>To read arguments value(s), use the dollar sign ($) followed by the position in which you inputted your values (positions start at 1, not 0).</p>
<p>In the example, if you want to echo the content of the second argument value, you can use <code>echo $2</code>.</p>
<p>To understand this better, let's enhance data input experience by passing the database credentials on the fly using arguments:</p>
<pre><code class="language-shell">#!/bin/bash

# database credentials

if [[ -z $1 ]]; then
    read -p 'DataBase-name(*): ' db
 else
    db="$1"
fi

# database checking and validating

if [[ -z $2 ]]; then
    read -p 'DataBase-user(*): ' user
 else
    user="$2"
fi

# user checking and validating

if [[ -z $1 ]]; then
    read -sp 'DataBase-password(*): ' pwd
 else
    pwd=$3
fi

# password vaidation and checking
</code></pre>
<p>The snippet first checks if there's an argument. If there aren't any, you use the prompt to input the value. If there are arguments, you assign the argument value to a variable that represents the given database credentials (database name, password, and so on...). Now you can run the script with arguments:</p>
<pre><code class="language-shell">bash image.sh customers ABC-Company secret123!
</code></pre>
<p>The image that will be created from the above script will have a database of <code>customers</code>, user <code>ABC-Company</code>, and a password of <code>secret123!</code>.</p>
<h3 id="heading-bash-flagsoptions">Bash Flags/Options</h3>
<p>The script has a section that asks for information about the image that you're creating, but the info can be optional. With bash option/flags, you can skip the step that prompts for container information input using the <code>-D</code> option. This lets you explicitly keep the default container info before the script runs.</p>
<p>Here's an example:</p>
<pre><code class="language-bash">
#!/bin/bash

while getopts "ny" options; do
	case "$options" in
		n) echo "You choose no";;
		y) echo "You choose yes";;
		*) echo "No such option/flag"; exit 1;;
    esac
done

shift $((OPTIND - 1))
</code></pre>
<p>In the above script:</p>
<ol>
<li>The while loop keeps running as long as <code>getopts</code> isn't empty</li>
<li><code>getopts</code> gets the passed option in the script</li>
<li><code>"ny"</code> are the options we're expecting from user when running the script</li>
<li><code>options</code> is a variable that will keep track of the input option between "n" and "y"</li>
<li><code>do</code> starts the loop</li>
<li><code>case</code> checks if the selected option is in the defined option using the <code>in</code> keyword</li>
<li>We then define what happens when we call the script with the option <code>-n</code> or <code>-y</code> and use a double semi-colon (;;) to close the option definition</li>
<li>The <code>*</code> is used in case the input options aren't defined.</li>
<li><code>esac</code> then closes the case</li>
<li><code>done</code> ends the loop so the loop doesn't continue running forever</li>
<li><code>shift $((OPTIND - 1))</code> helps avoid a conflict that may occur when the script also expects arguments by shifting the remaining arguments left <em>over</em> the flags, effectively discarding the flags from the parameter list.</li>
</ol>
<p>You can then apply the syntax in the script to skip the step that asks for container info when <code>-D</code> is passed as an option during the script execution.</p>
<pre><code class="language-shell">
#!/bin/bash

ask_container_info=true

while getopts "D" options; do
	case "$options" in
		D) ask_container_info=false;;
		*) echo "No such option/flag"; exit 1;;
    esac
done

shift $((OPTIND - 1))

if [[ $ask_container_info == true ]]; then
	#Prompt the user to input custom container information
    read -p 'Container-name: ' container_name
    read -p 'Container-port(if omitted, the container will use default postgresql default port of 5432): ' port
    read -p 'Volume-name: ' vol_name
fi
</code></pre>
<p>There is one option here, which is why the option section only has <code>D</code>. <code>ask_container_info</code> starts as true, meaning unless the option is passed, the script will prompt the user to enter the container information. We then change the value of <code>ask_container_info</code> to false when the <code>-D</code> is passed with the script's execution.</p>
<h2 id="heading-how-to-make-your-scripts-executable-and-available-on-your-pcs-path">How to Make Your Scripts Executable and Available on Your PC's Path</h2>
<p>The next step is to make the script available and executable in every terminal you use on your machine. At the moment, the script just works in the current directory you're using to create and write your scripts.</p>
<p>We'll start by making the script file executable and remove the file extension from the file, so we don't need to always call our script with the <code>.sh</code> extension.</p>
<h3 id="heading-how-to-make-a-file-executable">How to Make a File Executable</h3>
<p>To make a file executable, use the Linux <code>chmod</code> command. It stands for change mode. Mode includes file permissions like write, read, and execute.</p>
<pre><code class="language-shell">chmod +x image
</code></pre>
<p>Here, <code>x</code> makes the file executable, and then you've listed the file name you want to make executable (<code>image</code>).</p>
<h3 id="heading-how-to-add-your-directory-to-the-systemmachine-path">How to Add Your Directory to the <code>system/machine</code> Path</h3>
<p>To make this available in every terminal you open, regardless of the directory, you'll need to register your scripts in the system paths where all global scripts and commands are stored.</p>
<p>To do that, copy the full path of your directory and then in your terminal type the following:</p>
<pre><code class="language-shell">export PATH="$PATH:&lt;YOUR_DIRECTORY_LOCATION&gt;"
</code></pre>
<p>Replace <code>&lt;YOUR_DIRECTORY_LOCATION&gt;</code> with your directory. This command will add the script directory into the current working terminal. But if you try to switch to another terminal and run your script, it'll fail.</p>
<p>Now let's configure the directory globally so every terminal will be able to execute the script:</p>
<pre><code class="language-shell">nano ~/.bash_profile
</code></pre>
<p>After this you should see something that looks like this:</p>
<img src="https://cdn.hashnode.com/uploads/covers/69c7bcff7cf27065100ae8be/eb9d4588-4d21-43d5-a666-d406cdd9946d.png" alt="Nano editor for bash profiles and its contents" style="display: block;" width="600" height="400" loading="lazy">

<p>You can see in the image above that I already have my path declared in the file (see the selected text).</p>
<p>If it's not in you're file, you can copy-paste <code>export PATH="$PATH:&lt;YOUR_DIRECTORY_LOCATION&gt;"</code> inside the file. When you're done, press <code>Ctrl+O</code> and then <code>enter</code> to save. Then press <code>Ctrl+x</code> to exit the nano editor.</p>
<p>Then re-load the machine path again to include your scripts there:</p>
<pre><code class="language-shell">source ~/.bash_profile
</code></pre>
<p>After this, you'll be able to run your script in any terminal on your machine using the script file name only (I named my file <code>image</code>):</p>
<img src="https://cdn.hashnode.com/uploads/covers/69c7bcff7cf27065100ae8be/09dcf19f-0712-48f7-9ac6-f00723aa267c.png" alt="Output of a successfully script execution for the docker image creation script" style="display: block;" width="600" height="400" loading="lazy">

<h2 id="heading-conclusion">Conclusion</h2>
<p>In this guide, you learned how to create your own scripts to automate your workflows. I hope it helps you reduce the amount of energy and time you waste on repetitive tasks that can be automated using script commands.</p>
<p>You can find the full working CLI tool that we used as an example in this guide on this <a href="https://github.com/jabo-arnold-landry/Postgres-docker-image-generator">git-repo</a>. There you'll find the installation guide and usage tips. If you find it helpful, please consider starring the repo and sharing it with your collogues who might benefit from it.</p>
<p>Thanks!</p>
 ]]>
                </content:encoded>
            </item>
        
            <item>
                <title>
                    <![CDATA[ How to Deploy AI-Generated Code on a PaaS Platform ]]>
                </title>
                <description>
                    <![CDATA[ Vibe coding is about momentum. You open your editor, prompt an AI, stitch pieces together, and suddenly you have something that works. Maybe it’s messy. Maybe the architecture is not perfect. But it’s ]]>
                </description>
                <link>https://www.freecodecamp.org/news/deploy-ai-generated-code-using-paas/</link>
                <guid isPermaLink="false">69aa6fede2698e32064e7d79</guid>
                
                    <category>
                        <![CDATA[ deployment ]]>
                    </category>
                
                    <category>
                        <![CDATA[ vibe coding ]]>
                    </category>
                
                    <category>
                        <![CDATA[ AI ]]>
                    </category>
                
                <dc:creator>
                    <![CDATA[ Manish Shivanandhan ]]>
                </dc:creator>
                <pubDate>Fri, 06 Mar 2026 06:10:53 +0000</pubDate>
                <media:content url="https://cdn.hashnode.com/uploads/covers/5fc16e412cae9c5b190b6cdd/0b8cb97d-4c82-4e26-862f-a9def20b1612.png" medium="image" />
                <content:encoded>
                    <![CDATA[ <p>Vibe coding is about momentum. You open your editor, prompt an AI, stitch pieces together, and suddenly you have something that works.</p>
<p>Maybe it’s messy. Maybe the architecture is not perfect. But it’s live and working, and that’s the point.</p>
<p>Then comes deployment. This is where the vibe usually dies. Suddenly, you’re reading about containers, load balancers, CI/CD pipelines, infrastructure diagrams, and networking concepts you never asked for. You wanted to ship a thing. Instead, you’re learning accidental DevOps.</p>
<p>The truth is simple. Most vibe-coded apps don’t need complex infrastructure. They just need a clean path from code → live URL.</p>
<p>That’s where a Platform-as-a-Service fits in. It removes the infrastructure ceremony and lets deployment feel like a natural extension of building.</p>
<p>This guide is not about perfect production architecture. It’s about shipping fast without losing momentum. In this article, we will look at how to deploy a simple vibe-coded app using Sevalla. There are other options like Railway, render, and so on, with similar features, and you can <a href="https://www.freecodecamp.org/news/top-heroku-alternatives-for-deployment/">pick one from this list</a>.</p>
<h3 id="heading-what-vibe-deployment-actually-means">What “Vibe Deployment” Actually&nbsp;Means</h3>
<p>Traditional deployment advice assumes you’re building a long-term, heavily engineered system.</p>
<p>Vibe coders operate differently. The goal is speed, feedback, and iteration. A vibe-friendly deployment workflow has a few core characteristics:</p>
<ul>
<li><p><strong>Minimal configuration:</strong> You shouldn’t spend hours setting up environments before seeing your app live.</p>
</li>
<li><p><strong>Fast feedback loops:</strong> Every push should quickly show you the result.</p>
</li>
<li><p><strong>Safe defaults:</strong> You shouldn’t need deep infra knowledge to avoid obvious mistakes.</p>
</li>
</ul>
<p>In other words, deployment shouldn’t be a “phase.” It should be part of the normal development loop. You build. You push. It updates. You keep going.</p>
<h3 id="heading-the-typical-vibe-coded-app">The Typical Vibe-Coded App</h3>
<p>Most vibe-coded projects look similar under the hood. There’s usually a frontend generated or accelerated by AI using React, Next.js, Vue, or something equally modern. The backend might be a small API, sometimes written quickly without strict structure.</p>
<p>Data lives in a managed database. Authentication might be glued together from a few libraries.</p>
<p>The code evolves rapidly. Patterns change weekly. Files get renamed, rewritten, or deleted without ceremony. And that’s fine.</p>
<p>The problem is that traditional deployment workflows assume stability and planning. They expect clean separation between environments, carefully defined build pipelines, and long-term operational thinking.</p>
<p>Vibe-coded apps need the opposite: something that tolerates change and rewards experimentation.</p>
<h3 id="heading-the-paas-mental-model">The PaaS Mental&nbsp;Model</h3>
<p>The biggest shift with a PaaS is how you think about deployment. Instead of asking:</p>
<ul>
<li><p>Which server should I use?</p>
</li>
<li><p>How do I configure networking?</p>
</li>
<li><p>What container setup do I need?</p>
</li>
<li><p>How do I maintain and run my server 24/7?</p>
</li>
</ul>
<p>You think in terms of:</p>
<ul>
<li><p>Connect your repository.</p>
</li>
<li><p>Configure the app once.</p>
</li>
<li><p>Deploy automatically.</p>
</li>
</ul>
<p>A PaaS treats your project as a service that can be built and run. You don’t manage infrastructure, you define the minimum information needed to run your code.</p>
<p>There are only a few concepts you really need to understand:</p>
<ul>
<li><p><strong>Services:</strong> Each deployable unit of your app. A frontend or backend typically becomes a service.</p>
</li>
<li><p><strong>Environment variables:</strong> Secrets and configuration that differ between local and production.</p>
</li>
<li><p><strong>Auto builds:</strong> Every code push triggers a build and deployment.</p>
</li>
</ul>
<p>That’s it. The system handles the rest. The result is important: deployment stops being a separate discipline and becomes just another part of coding.</p>
<h3 id="heading-how-to-ship-your-first-app-on-sevalla">How to Ship Your First App on&nbsp;Sevalla</h3>
<p><a href="https://sevalla.com/">Sevalla</a> is a developer-friendly PaaS provider. It offers application hosting, database, object storage, and static site hosting for your projects.</p>
<p>Let’s walk through what deployment actually looks like in practice. I have already written a few tutorials on both <a href="https://www.freecodecamp.org/news/how-to-build-and-deploy-a-loganalyzer-agent-using-langchain/">Python</a> and <a href="https://www.freecodecamp.org/news/build-and-deploy-an-image-hosting-service-on-sevalla/">Node.js</a> projects, building an app from scratch and deploying it on Sevalla.</p>
<h4 id="heading-step-1-connect-your-repository">Step 1: Connect Your Repository</h4>
<p>The starting point is your Git repository. <a href="https://app.sevalla.com/login">Log in</a> to Sevalla using your GitHub account, or you can connect it after logging in with your email.</p>
<p>You connect your project to Sevalla and select the branch you want to deploy. This creates a direct link between your code and the live app.</p>
<img src="https://cdn.hashnode.com/uploads/covers/66c6d8f04fa7fe6a6e337edd/dd0c1f28-0699-45a6-8ab6-316a9a17e780.png" alt="Creating an application" style="display: block;" width="1000" height="626" loading="lazy">

<p>You can also enable “Automatic deployments”. Once you create an app, deployment becomes automatic. You push code, and Sevalla takes care of building and publishing.</p>
<p>No manual uploads. No SSH sessions. No server setup.</p>
<h4 id="heading-step-2-configure-the-runtime">Step 2: Configure the&nbsp;Runtime</h4>
<p>Next, you define how your app runs. Most modern frameworks are detected automatically. If you’ve built something common, you usually won’t need to tweak much.</p>
<p>This is where you add environment variables. API keys, database URLs, authentication secrets, and anything that shouldn’t live inside your codebase.</p>
<img src="https://cdn.hashnode.com/uploads/covers/66c6d8f04fa7fe6a6e337edd/daa3f518-c9fe-412b-959b-7d46931efad1.png" alt="Adding environment variables" style="display: block;" width="1000" height="240" loading="lazy">

<p>A simple rule for vibe coders: If it changes between local and production, make it an environment variable. Once set, you rarely need to touch this again.</p>
<h4 id="heading-step-3-deploy">Step 3:&nbsp;Deploy</h4>
<p>Now you deploy. Sevalla builds the application, installs dependencies, and launches it. After a short wait, you get a live URL.</p>
<p>This is the moment that matters. Your app is no longer a local experiment, it’s something real people can use. And importantly, you didn’t need to make infrastructure decisions to get there.</p>
<h4 id="heading-step-4-iterate-like-a-vibe-coder">Step 4: Iterate Like a Vibe&nbsp;Coder</h4>
<p>Now your workflow shines! You make a change locally. Commit. Push. Sevalla rebuilds and redeploys automatically. Your deployment process becomes invisible, just part of your normal coding rhythm.</p>
<p>This matters more than most people realize. When deployment is effortless, you ship more often. When you ship more often, you learn faster. And fast learning is the real advantage of vibe coding.</p>
<h3 id="heading-things-vibe-coders-usually-break-and-how-paas-helps">Things Vibe Coders Usually Break (and How PaaS&nbsp;Helps)</h3>
<p>Even simple deployment workflows can go wrong. Some patterns show up repeatedly.</p>
<ul>
<li><p><strong>Missing environment variables:</strong> The app works locally but crashes in production. A PaaS surfaces configuration clearly, making it easier to spot.</p>
</li>
<li><p><strong>Localhost assumptions.</strong> Hardcoded URLs or local file paths break once deployed. Using environment configuration fixes this early.</p>
</li>
<li><p><strong>File storage confusion.</strong> Local files disappear between deployments. Treat storage as external from day one.</p>
</li>
<li><p><strong>Ignoring logs.</strong> Many developers only look at logs after panic sets in. Sevalla’s centralized logs make debugging faster when something inevitably fails.</p>
</li>
</ul>
<img src="https://cdn.hashnode.com/uploads/covers/66c6d8f04fa7fe6a6e337edd/c1d0d65d-3962-4b18-a8b6-5801a02dd303.png" alt="Logs" style="display: block;" width="1000" height="461" loading="lazy">

<p>The important point: these aren’t advanced problems. They’re beginner deployment mistakes, and the platform’s defaults help you avoid most of them.</p>
<h3 id="heading-the-minimal-production-checklist">The Minimal Production Checklist</h3>
<p>Before you call something “live,” run through a quick checklist:</p>
<ul>
<li><p>Environment variables are set correctly.</p>
</li>
<li><p>The database is external, not local.</p>
</li>
<li><p>Logs are enabled and readable.</p>
</li>
<li><p>Custom domain is connected if needed.</p>
</li>
<li><p>You know how to roll back to a previous version.</p>
</li>
</ul>
<p>That’s enough for most early-stage projects. You don’t need complex monitoring stacks or multi-region infrastructure to start learning from real users.</p>
<h3 id="heading-why-this-workflow-works-for-vibe-builders">Why This Workflow Works for Vibe&nbsp;Builders</h3>
<p>Indie builders and vibe coders succeed by maintaining velocity. The highest hidden cost in software isn’t infrastructure, it’s context switching.</p>
<p>Every time you stop building to become a part-time DevOps engineer, momentum drops.</p>
<p>A PaaS system’s biggest advantage isn’t technical sophistication. It’s psychological. You stay in the builder mindset. You focus on product decisions instead of infrastructure decisions.</p>
<p>And because deployment feels safe, you ship more frequently. Small releases reduce risk, reduce anxiety, and make experimentation normal. This is exactly the environment where small projects grow into real products.</p>
<h2 id="heading-conclusion">Conclusion</h2>
<p>The best deployment system is one you barely think about. For vibe coders, deployment shouldn’t be a scary milestone or a weekend project. It should feel like pressing save, just another step in the creative loop.</p>
<p>Build something. Push it live. Learn from users. Repeat. That’s the real goal. And when deployment stops being a bottleneck, the vibe stays alive.</p>
 ]]>
                </content:encoded>
            </item>
        
            <item>
                <title>
                    <![CDATA[ How to Use Vibe Coding Effectively as a Dev ]]>
                </title>
                <description>
                    <![CDATA[ It may seem like everyone is a vibe coder these days, and prompting seemed like it would become the new coding. But is this AI-generated code really deployable? Bragging on social media about a clever script is one thing, but pushing a vibe coded app... ]]>
                </description>
                <link>https://www.freecodecamp.org/news/how-to-use-vibe-coding-effectively-as-a-dev/</link>
                <guid isPermaLink="false">6925deb0b459e862808eb04c</guid>
                
                    <category>
                        <![CDATA[ General Programming ]]>
                    </category>
                
                    <category>
                        <![CDATA[ Programming Blogs ]]>
                    </category>
                
                    <category>
                        <![CDATA[ software development ]]>
                    </category>
                
                    <category>
                        <![CDATA[ Web Development ]]>
                    </category>
                
                    <category>
                        <![CDATA[ vibe coding ]]>
                    </category>
                
                <dc:creator>
                    <![CDATA[ Ankur Tyagi ]]>
                </dc:creator>
                <pubDate>Tue, 25 Nov 2025 16:52:00 +0000</pubDate>
                <media:content url="https://cdn.hashnode.com/res/hashnode/image/upload/v1764089459731/0122c0b7-08e2-434a-b5eb-518025401951.png" medium="image" />
                <content:encoded>
                    <![CDATA[ <p>It may seem like everyone is a vibe coder these days, and prompting seemed like it would become the new coding. But is this AI-generated code really deployable?</p>
<p>Bragging on social media about a clever script is one thing, but pushing a vibe coded app to prod comes with many security risks.</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1758881769141/9bedc585-5608-4660-a304-bbb10f10b8f2.png" alt="Vibe-debug, vibe-refactor, and vibe-check" class="image--center mx-auto" width="4276" height="3094" loading="lazy"></p>
<p>With so many AI dev tools out there now, <a target="_blank" href="https://www.freecodecamp.org/news/how-to-perform-code-reviews-in-tech-the-painless-way/">code reviews</a> become more critical than ever.</p>
<p>This article will explore what <strong>vibe coding</strong> means and how code reviews should adapt in the era of AI.</p>
<h2 id="heading-table-of-contents"><strong>Table of Contents:</strong></h2>
<ol>
<li><p><a class="post-section-overview" href="#heading-what-is-vibe-coding">What is Vibe Coding?</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-how-to-implement-vibe-coding-in-practice">How to Implement Vibe Coding in Practice</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-why-isnt-vibe-coded-output-production-ready">Why isn’t Vibe Coded Output Production Ready?</a></p>
<ul>
<li><p><a class="post-section-overview" href="#heading-context-gaps-are-the-first-crack">Context gaps are the first crack.</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-those-gaps-lead-directly-to-integration-blind-spots">Those gaps lead directly to integration blind spots.</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-the-most-serious-risk-is-security-by-omission">The most serious risk is security by omission.</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-testing-and-correctness-evidence-are-thin">Testing and correctness evidence are thin.</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-operability-lags-behind">Operability lags behind.</a></p>
</li>
</ul>
</li>
<li><p><a class="post-section-overview" href="#heading-guidelines-for-ai-code-reviews">Guidelines for AI Code Reviews</a></p>
<ul>
<li><a class="post-section-overview" href="#heading-code-review-process-in-vibe-coding">Code Review Process in Vibe Coding</a></li>
</ul>
</li>
<li><p><a class="post-section-overview" href="#heading-checklist-for-reviewing-ai-generated-code">Checklist for Reviewing AI Generated Code</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-how-to-work-effectively-with-ai-tools">How to Work Effectively with AI Tools</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-conclusion">Conclusion</a></p>
</li>
</ol>
<h2 id="heading-what-is-vibe-coding">What is Vibe Coding?</h2>
<p>In early 2025, AI researcher <a target="_blank" href="https://x.com/karpathy">Andrej Karpathy</a> popularized the term vibe coding to describe a new way of development in which you “fully give in to the vibes” and let AI write code while you focus on high level intent.</p>
<p>A developer expresses their desired functionality in plain language, and an AI system (like an <a target="_blank" href="https://en.wikipedia.org/wiki/Large_language_model">LLM</a>) generates the source code to implement it.</p>
<p>This code-by-prompt approach allows even beginners to produce working code without deep knowledge of programming languages. Karpathy joked that with advanced IDE agents (like <a target="_blank" href="https://www.devtoolsacademy.com/blog/cursor-vs-windsurf/">Cursor’s</a> Composer mode), “I barely even touch the keyboard... I ‘Accept All’ always, I don’t read the diffs anymore... and it mostly works”.</p>
<p>So, vibe coding is coding by vibe and trusting AI to handle the heavy lifting.</p>
<h2 id="heading-how-to-implement-vibe-coding-in-practice">How to Implement Vibe Coding in Practice</h2>
<p>In practice, vibe coding usually involves using AI assistants and adapting your workflow to a more interactive, prompt-driven style.</p>
<p>Here’s an overview of how you can “vibe code” a project:</p>
<h3 id="heading-step-1-choose-an-ai-assistant">Step 1: Choose an AI assistant</h3>
<p>Select a development env that supports AI code generation. Popular choices include <a target="_blank" href="https://cursor.com/">Cursor</a> and <a target="_blank" href="https://github.com/features/copilot">GitHub Copilot</a>.</p>
<h3 id="heading-step-2-define-your-requirements">Step 2: Define your requirements</h3>
<p>Instead of writing boilerplate code, describe what you want to build. Provide AI with a specific prompt detailing functionality. The more <a target="_blank" href="https://www.philschmid.de/context-engineering">context</a> and detail you give, the better AI can fulfill your intent.</p>
<p>For example, when I ran an SEO inspection for my website, DevTools Academy, I used this prompt in Cursor:</p>
<blockquote>
<p>“Now, act as a senior product engineer and UX strategist. Evaluate and improve <a target="_blank" href="https://www.devtoolsacademy.com">https://www.devtoolsacademy.com</a> with a practical, no-fluff lens.</p>
<p>Scope:</p>
<ul>
<li><p>UX</p>
</li>
<li><p>SEO and technical SEO</p>
</li>
<li><p>Positioning and messaging</p>
</li>
<li><p>Copywriting and information architecture</p>
</li>
<li><p>What to add to stand out in the developer tools space.”</p>
</li>
</ul>
</blockquote>
<p>This prompt works well because it gives the AI a clear role, a defined scope, and a specific intent. AI knows it’s not just fixing SEO but also reviewing how the site communicates value to devs. That combination of clarity and context produces actionable insights instead of surface-level suggestions.</p>
<p>Below is a screenshot of that audit in progress and showing how I reviewed code, metadata, and UX recommendations side by side.</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1761258218099/91e93726-1a7d-4d1a-9839-531355037dfc.png" alt="cursor screenshot showing CodeRabbit reviewing a pull request with comments and summary." class="image--center mx-auto" width="4276" height="2680" loading="lazy"></p>
<p>You can checkout the full code on my open source <a target="_blank" href="https://github.com/tyaga001/devtoolsacademy">blog</a> here and check out closed PRs. This will help you learn how I use all these coding agents on a production ready app.</p>
<h3 id="heading-step-3-review-the-code">Step 3: Review the code</h3>
<p>AI will produce initial code based on your prompt. Think of this as a prototype – it’s not perfect. Run the code and see how it behaves.</p>
<p>Let’s look at an example: here, CodeRabbit is reviewing one of my <a target="_blank" href="https://github.com/tyaga001/devtoolsacademy/pull/145">pull requests</a> on GitHub. I had pushed a small fix to sort blog posts correctly and make sure the RSS feed reflects the latest publish date. Within seconds, CodeRabbit analyzed the diff, understood the intent behind my change, and explained exactly what the new code does.</p>
<p>It pointed out that the fix now sorts posts before mapping them, uses the sorted data for both items and the lastBuildDate, and ensures proper chronological order throughout the feed.</p>
<p>It’s like having a senior reviewer who not only checks syntax but also validates logic and confirms that your reasoning holds up.</p>
<p><a target="_blank" href="https://github.com/tyaga001/devtoolsacademy/pull/145"><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1758879621613/95bee1e7-3953-4416-b48b-e844332be950.png" alt="GitHub pull request showing CodeRabbit review comments on code changes with highlighted fixes." class="image--center mx-auto" width="4276" height="2644" loading="lazy"></a></p>
<p>This is just a reminder to expect imperfections. Vibe coding embraces a <em>“code first, refine later”</em> mindset. This means you get a working version quickly, then iteratively improve it. You might go through a few cycles of prompt -&gt; code -&gt; test -&gt; tweak.</p>
<h3 id="heading-step-4-validate-debug-polish">Step 4: Validate, debug, polish</h3>
<p>Once AI generated code meets your expectations, do a final review.</p>
<p>Throughout the process, the core idea is that you collaborate with the AI. The AI agent serves as a coding assistant, making real-time suggestions, automating tedious boilerplate, and even generating entire modules on your behalf.</p>
<h2 id="heading-why-isnt-vibe-coded-output-production-ready">Why Isn’t Vibe Coded Output Production Ready?</h2>
<p>Vibe coding moves fast: you describe intent, the AI produces something that runs, and you’re off to the next prompt. What’s missing is the slow, unglamorous work that usually turns a draft into shippable software, like shared context, architectural alignment, verification, and documentation.</p>
<p>AI generates plausible code based on patterns it has seen. But it doesn’t understand your team’s history, your system’s constraints, or the implicit rules that keep everything coherent over time.</p>
<p>That mismatch shows up the moment a “works on my machine” demo meets a real codebase.</p>
<p>Let’s explore the common pitfalls of vibe-coded code, so you’ll know what to watch for. Then, in the checklist section below, I’ll outline practical strategies to address or prevent each issue.</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1758271815928/5f763a0f-2dda-4318-8c19-0c9e58447abe.png" alt="AI is Limited by Context" class="image--center mx-auto" width="740" height="520" loading="lazy"></p>
<h3 id="heading-context-gaps-are-the-first-crack">Context gaps are the first crack.</h3>
<p>AI only sees what you show it, so it’s easy for it to make the right local choice and the wrong global one: duplicating logic that already exists, choosing defaults that conflict with prior decisions, or introducing functions that don’t respect domain boundaries.</p>
<p>The result is code that looks reasonable in isolation but collides with existing assumptions and conventions once integrated.</p>
<h3 id="heading-those-gaps-lead-directly-to-integration-blind-spots">Those gaps lead directly to integration blind spots.</h3>
<p>Drafts often ignore the lived details of your environment – shared utilities, cross-cutting concerns, configuration, deployment hooks, and operational policies. Interfaces may line up at a glance and still fail at runtime because the draft doesn’t fit how your system composes modules, handles errors, or manages state across services.</p>
<h3 id="heading-the-most-serious-risk-is-security-by-omission">The most serious risk is security by omission.</h3>
<p>AI rarely includes robust input validation, clear authentication and authorization paths, or rate limiting unless you spell it out. Secrets handling and logging tend to be superficial or missing. That leaves common exposure points like request handlers, job processors, and webhook endpoints without the checks that prevent injection, SSRF, mass assignment, or data exfiltration.</p>
<p>Even when the surface looks tidy, the absence of explicit security controls means you’re trusting defaults you didn’t choose.</p>
<h3 id="heading-testing-and-correctness-evidence-are-thin">Testing and correctness evidence are thin.</h3>
<p>Quality suffers in quieter ways, too. Beyond “it runs,” there’s little to demonstrate behavior across edge cases or to guard against regressions.</p>
<p>Performance and scalability remain unknowns: extra network calls, N+1 patterns, and quadratic loops sneak in because nobody measured them. Dependencies and environments drift as versions aren’t pinned, infrastructure isn’t declared, and configuration lives only in the author’s head, making behavior differ across machines and CI.</p>
<h3 id="heading-operability-lags-behind">Operability lags behind.</h3>
<p>A lack of metrics, missing health/readiness probes, and no runbook make failures harder to detect and slower to recover from. Add in data quality and compliance concerns (PII handling, encoding assumptions, transitive license obligations), and you have code that demos well but isn’t ready for production’s reliability, security, and audit demands.</p>
<p>In short, vibe-coded output accelerates drafting but skips the shared understanding and evidence that make software safe to ship.</p>
<p>Until those gaps are closed, it’s a prototype, not a release.</p>
<h2 id="heading-guidelines-for-ai-code-reviews">Guidelines for AI Code Reviews</h2>
<p>Your team should keep pre-AI engineering standards as the bar, including security, tests, readability, maintainability, performance, and docs. AI should change how fast you gather the evidence for those standards, not how much evidence you require. In other words, use AI to accelerate the path to your existing bar, never to lower it.</p>
<p>Using AI, you can generate code at speed. But if reviews take the same amount of time (or more time), you lose some of the benefit. The goal isn’t to relax standards, it’s to shorten the time to prove you met them. That means layering in automation (tests, static analysis, secret scans, SCA) and AI-assisted review to catch obvious issues quickly so human reviewers can focus on intent, architecture, and risk.</p>
<p>Well-used assistants can help here. For example, tools like CodeRabbit, GitHub Copilot PR Reviewer, Claude Code, Cursor’s Bugbot, Graphite’s AI Review, and Greptile can highlight potential bugs, security gaps, style deviations, and mismatched intent, and summarize diffs for faster context. Treat these as accelerators for your existing process, not as replacements for judgment.</p>
<h3 id="heading-code-review-process-in-vibe-coding">Code Review Process in Vibe Coding</h3>
<p>The fundamentals of good code reviews haven’t changed – and in fact, they’re more critical now.</p>
<p>Below are some key principles to maintain speed without sacrificing quality.</p>
<h4 id="heading-1-trust-but-verify">1. Trust, but verify.</h4>
<p>A reviewer usually assumes the author understands the system. With vibe-coded output, the “author” may be an AI with limited context. If something looks odd or unnecessary, question it. Run the code, add/execute tests, or ask the developer/AI for clarification on intent and constraints.</p>
<h4 id="heading-2-dont-let-reviews-become-a-bottleneck">2. Don’t let reviews become a bottleneck.</h4>
<p>Vibe coding generates code quickly. If human review takes as long as hand-writing the change, you’ve erased the gain.</p>
<p>Combat this by front-loading automation: run unit/integration tests, static analysis (lint/SAST), secret scans, SCA, and basic perf checks in CI to clear the noise. Then reviewers spend their time on design trade-offs, boundary cases, and risk. The balance is: high standards, faster evidence.</p>
<h4 id="heading-3-use-ai-code-reviews-wisely">3. Use AI code reviews wisely</h4>
<p>AI can help review code just as it helps generate it. Modern “pair reviewer” tools scan a PR and surface likely bugs, security issues, missing tests, or style violations in minutes plus give natural-language summaries of the change.</p>
<p>Tools you can consider include CodeRabbit, GitHub Copilot PR Reviewer, Claude Code, Cursor Bugbot, Graphite, and Greptile. Many integrate with the CLI/IDE and GitHub/GitLab to leave actionable comments.</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1758272500586/a9cc891f-ab1a-47d8-a607-a772cbaef2e0.png" alt="coderabbit CLI" class="image--center mx-auto" width="4276" height="2722" loading="lazy"></p>
<p>Think of them as fast first-pass reviewers that increase coverage and consistency across PRs.</p>
<h4 id="heading-4-human-judgment-is-still-irreplaceable">4. Human judgment is still irreplaceable.</h4>
<p>Even the best AI reviewer is an assistant. Keep humans accountable for correctness, security posture, architectural fit, and user impact. A healthy pattern is AI first-pass &gt; human second-pass that inspects invariants, failure modes, and long-term maintainability.</p>
<h4 id="heading-5-maintain-a-high-bar-for-quality">5. Maintain a high bar for quality.</h4>
<p>It’s tempting to accept “it runs” when an AI wrote it. Don’t. Stakeholders still expect software to be robust, secure, and maintainable. Keep DRY, readability, and testability standards. Insist on input validation, authZ checks where relevant, and sensible logging/metrics. If you can’t provide evidence that you met the bar, you haven’t met it.</p>
<h4 id="heading-6-educate-and-document">6. Educate and document</h4>
<p>When reviewers find bugs or security flaws in AI-generated code, capture the lesson.</p>
<p>Update internal guides with patterns like “When generating handlers, validate and bound inputs, add rate limits, log request IDs, avoid N+1 queries, and sanitize user-visible output.” Over time, bake these into prompts, templates, repo scaffolds, and CI checks so the next AI draft starts closer to done.</p>
<h2 id="heading-checklist-for-reviewing-ai-generated-code">Checklist for Reviewing AI Generated Code</h2>
<p>Before approving any vibe-coded change, make the standards explicit and verifiable. Use this checklist to confirm behavior, security, performance, integration, and documentation so the draft you got from AI becomes code you can safely ship.</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1762510535966/85ea547a-f955-446b-9e22-965dc18f9e49.png" alt="Checklist for Reviewing AI Generated Code" class="image--center mx-auto" width="2696" height="2044" loading="lazy"></p>
<p>Here’s a checklist a human reviewer should go through before approving vibe-coded output:</p>
<h3 id="heading-1-define-the-codes-purpose-scope-amp-non-goals">1. Define the code’s purpose (scope &amp; non-goals).</h3>
<p>Be explicit about what this change does and does not do. Tie it to a user story/ticket and call out non-goals so “helpful” AI changes don’t creep in.</p>
<h3 id="heading-2-verify-x-and-y-behavior-and-edge-cases">2. Verify X and Y (behavior and edge cases).</h3>
<p>Be clear about what you’re verifying. For example, verify input parsing and pagination boundaries, verify that error paths return the correct status and body, and verify that database writes are idempotent. Run existing tests, add missing unit/integration tests, and reproduce edge inputs (empty, null, huge, unicode).</p>
<h3 id="heading-3-perform-code-quality-checks-readability-dry-refactor-needs">3. Perform code-quality checks (readability, DRY, refactor needs).</h3>
<p>AI often produces verbose or duplicated logic. Ensure names are meaningful, side effects are clearly stated, and duplication is removed or minimized. Run linters/formatters, collapse repetition, and extract helpers where they aid clarity.</p>
<h3 id="heading-4-analyze-organization-and-structure-make-sure-it-fits-the-architecture">4. Analyze organization and structure (make sure it fits the architecture).</h3>
<p>AI writes code in isolation. Confirm the change uses existing utilities, layers, and boundaries (domain/services/controllers/jobs). Check imports and module placement, avoid reinventing existing helpers, and align with repository conventions.</p>
<h3 id="heading-5-validate-inputs-and-assumptions-make-the-implicit-explicit">5. Validate inputs and assumptions (make the implicit explicit).</h3>
<p>List the assumptions the AI made (default locale/timezone, allowed ranges, required fields). Add schema validation (DTO/class validators/JSON Schema). Empty, null, over-max, non-ASCII, unexpected enum, malicious strings. And finally, enforce limits/timeouts.</p>
<h3 id="heading-6-perform-security-audits-minimum-pass">6. Perform security audits (minimum pass).</h3>
<ul>
<li><p><strong>AuthN/AuthZ:</strong> Confirm endpoint checks identity and authorization paths; deny-by-default.</p>
</li>
<li><p><strong>Inputs:</strong> Sanitize/validate inputs, prevent injection (SQL/NoSQL/command), and escape user-visible output.</p>
</li>
<li><p><strong>Secrets</strong>: No secrets in code/diff/logs, use env/secret manager, and rotate any test keys.</p>
</li>
<li><p><strong>Abuse controls:</strong> Add rate limits, size limits, and timeouts on network and disk operations. Run SAST/secret scan/SCA, and fix or justify findings.</p>
</li>
</ul>
<h3 id="heading-7-do-a-performance-evaluation-right-now-at-a-small-scale">7. Do a performance evaluation (right now, at a small scale).</h3>
<p>Look for N+1s, needless network calls, unbounded loops, quadratic sorts. Add a micro-benchmark or run a quick load test for hot paths. Set sensible cache/timeout/retry with jitter where applicable.</p>
<h3 id="heading-8-manage-dependencies-pin-justify-minimize">8. Manage dependencies (pin, justify, minimize).</h3>
<p>Review any new libraries. Are they necessary? Maintained? License compatible? Pin versions, add lockfiles, or remove unused transitive adds.</p>
<h3 id="heading-9-review-documentation-what-to-add-and-where">9. Review documentation (what to add and where).</h3>
<p>Ensure the docs are in line with the code. AI often changes some parts or adds code blocks at different places while resolving various issues. These changes might not make it into the docs.</p>
<h3 id="heading-10-observability-see-problems-early">10. Observability (see problems early).</h3>
<p>Use structured logs with request/trace IDs, key counters/timers (success/error/latency), health/readiness probes, and a basic dashboard or alert stub.</p>
<h3 id="heading-11-compliance-and-data-handling-when-applicable">11. Compliance and data handling (when applicable).</h3>
<p>Identify any personally identifiable information (PII), document collection/retention, ensure masking/redaction in logs, verify dependency licenses and data-residency constraints.</p>
<h2 id="heading-how-to-work-effectively-with-ai-tools">How to Work Effectively with AI Tools</h2>
<p>At this point, you can probably see why it’s very important to understand the actual skills involved in AI-assisted development.</p>
<p>There’s a pretty big difference between an experienced developer who uses AI tools to help them get more done, and a newbie who thinks AI can build the next Facebook or Google just with a simple prompt.</p>
<p>An inexperienced dev will ask AI something like "Hey, Build me Twitter and make no mistakes"</p>
<p>But an experienced developer who has a solid fundamentals might say say something like:</p>
<ul>
<li><p>"AI, we're building a Twitter replica. Use $SQL_Database, Use $Language, Avoid $Common_Pitfalls, Follow $Standard_Practices."</p>
</li>
<li><p>"The generated code is prone to X problem, implement this fix."</p>
</li>
<li><p>"Implementation of $X is flawed because of $Y, do $Z instead."</p>
</li>
</ul>
<p>So as you can see, you still need to know the how's and the why's and what depends on what. Often you’ll just need to make the changes manually, because it will be faster. And you don’t want to outsource the critical thinking part, which is the part that AI can't actually do.</p>
<p>LLMs are good at information retrieval. If you know nothing about what you’re looking for, then asking an AI isn’t going to be that helpful (or that reliable). But if you have an idea, some background knowledge/context, and the skills to verify AI’s responses, then it can be really helpful.</p>
<p>Last month, I shared in my <a target="_blank" href="https://bytesizedbets.com/">newsletter</a> how my current coding loop looks in practice.</p>
<p>I draft with Claude Code (or Copilot/Cursor), open a PR, and let an AI reviewer like CodeRabbit (or Copilot PR Reviewer / Cursor Bugbot or Greptile) do the first pass. CI runs tests and scans.</p>
<p>I repeat until everything’s green and the PR is ready to merge. It’s fast, but it’s still disciplined.</p>
<p>If you want to understand why this kind of workflow is becoming essential, read this article: <a target="_blank" href="https://bytesizedbets.com/p/era-of-ai-slop-cleanup-has-begun">Era of AI Slop Cleanup Has Begun</a>. I talk about what’s happening in AI-assisted engineering, where generating code is easy, but keeping it clean and production ready takes experience – and you must have good programming skills.</p>
<h2 id="heading-conclusion">Conclusion</h2>
<p>AI-generated code can boost productivity – but production value still comes from software that is robust, secure, and maintainable.</p>
<p>Mindless code generation creates technical debt. But when you integrate AI thoughtfully, with guardrails, verification, tests, security checks, and documentation, you can go faster without lowering your standards.</p>
<p>That's it for this article. I hope you learned something new today.</p>
<p>If you have any questions about code reviews, engineering, startups, or business in general, please find me on Twitter: <a target="_blank" href="https://x.com/TheAnkurTyagi">@TheAnkurTyag</a>i. I’d be more than happy to discuss them.</p>
<h3 id="heading-want-to-read-more-interesting-articles-like-this">Want to read more interesting articles like this?</h3>
<p>You can read more about the latest dev tools like this one on my <a target="_blank" href="https://www.devtoolsacademy.com/">website</a>.</p>
 ]]>
                </content:encoded>
            </item>
        
            <item>
                <title>
                    <![CDATA[ How to Vibe Code With Help From n8n ]]>
                </title>
                <description>
                    <![CDATA[ Learn the power of vibe coding and how it pairs perfectly with n8n to build full-stack AI-driven apps. We just published a crash course on the freeCodeCamp.org YouTube channel that will teach you the power of VibeCoding and how to automate real-world... ]]>
                </description>
                <link>https://www.freecodecamp.org/news/how-to-vibe-code-with-help-from-n8n/</link>
                <guid isPermaLink="false">686e78b53e3a3fb3bf0c79eb</guid>
                
                    <category>
                        <![CDATA[ vibe coding ]]>
                    </category>
                
                    <category>
                        <![CDATA[ youtube ]]>
                    </category>
                
                    <category>
                        <![CDATA[ n8n ]]>
                    </category>
                
                <dc:creator>
                    <![CDATA[ Beau Carnes ]]>
                </dc:creator>
                <pubDate>Wed, 09 Jul 2025 14:12:05 +0000</pubDate>
                <media:content url="https://cdn.hashnode.com/res/hashnode/image/upload/v1751989831875/d04a4ccc-1159-4ff1-944b-d75399a55a2e.jpeg" medium="image" />
                <content:encoded>
                    <![CDATA[ <p>Learn the power of vibe coding and how it pairs perfectly with n8n to build full-stack AI-driven apps.</p>
<p>We just published a crash course on the freeCodeCamp.org YouTube channel that will teach you the power of VibeCoding and how to automate real-world workflows using n8n. This course starts by demystifying what software engineers actually do and introduces you to the VibeCoding movement, which is an approach that blends human creativity with AI-driven automation. Paulo Dichone from Vinci bits created this course.</p>
<p>You’ll learn about the origins of VibeCoding, why it’s accessible to everyone, and how it can transform your approach to building software. The course walks through the entire vibe coding workflow, connecting it to core software engineering principles so you can vibe code like a pro.</p>
<p>A key part of this course is n8n, an open-source workflow automation tool that lets you connect different apps, APIs, and services without writing tons of code. Think of n8n as a visual platform where you can drag, drop, and link together building blocks to automate tasks, process data, and build complex backend systems.</p>
<p>You will learn how to set up n8n, create your first workflows and webhooks, and use AI coding agents to build powerful frontends that interact with your automated backend. Along the way, you’ll tackle real challenges like processing files, handling binary data, and troubleshooting workflow issues.</p>
<p>Here are the different sections covered in this course:</p>
<ul>
<li><p>What do Software Engineers do?</p>
</li>
<li><p>Vibe Coding - Who Started This Movement?</p>
</li>
<li><p>Fear Not Vibe Coding - Here’s Why</p>
</li>
<li><p>Vibe Coding - the Full Workflow</p>
</li>
<li><p>Bring it All Together - Vibecoding and Software Engineering Principles - Vibecoding Like an Engineer</p>
</li>
<li><p>LLM and Context - Why Does it Matter?</p>
</li>
<li><p>The Path to Follow when Vibe Coding</p>
</li>
<li><p>How To Think About Vibe Coding to Build Production Applications</p>
</li>
<li><p>Setting up N8N</p>
</li>
<li><p>Basics on N8N - Create your First Workflow and Webhooks</p>
</li>
<li><p>Leveraging AI Coding Agents to Build the Frontend - Intro to <a target="_blank" href="http://Bolt.new">Bolt.new</a> - Upload Files to our N8N Backend</p>
</li>
<li><p>Adding an N8N Switch Node to our Backend Workflow - Processing PDF, TXT, and CSV Files</p>
</li>
<li><p>Understanding Binary Files and Troubleshooting N8N Issues</p>
</li>
<li><p>An Overview of the Workflow Architecture - Bulletproofing the Workflow for Further Processing Downstream</p>
</li>
<li><p>Adding a Code Node to our N8N Workflow for Processing Data</p>
</li>
<li><p>Deconstructing the Field Extraction Node Code</p>
</li>
<li><p>Combining Extracted Data through the Code Node</p>
</li>
<li><p>Testing the Workflow - Full File Upload and File Processing Workflow</p>
</li>
<li><p>Final Thoughts and Where to Go From Here</p>
</li>
</ul>
<p>By the end of this course, you’ll have the VibeCoding mindset and a production-ready AI automation system built with n8n and AI tools. Watch the full course <a target="_blank" href="https://youtu.be/qDtVzumlb8M">on the freeCodeCamp.org YouTube channel</a> (2-hour watch).</p>
<div class="embed-wrapper">
        <iframe width="560" height="315" src="https://www.youtube.com/embed/qDtVzumlb8M" style="aspect-ratio: 16 / 9; width: 100%; height: auto;" title="YouTube video player" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen="" loading="lazy"></iframe></div>
 ]]>
                </content:encoded>
            </item>
        
            <item>
                <title>
                    <![CDATA[ Why Vibe Coding Won't Destroy Software Engineering ]]>
                </title>
                <description>
                    <![CDATA[ AI is disrupting all industries at a pace not seen at any time in history. Technologies and industries that were once dominated by one or two companies or were very much “human-focused” are coming under threat. Google is losing ground to AI search, t... ]]>
                </description>
                <link>https://www.freecodecamp.org/news/why-vibe-coding-wont-destroy-software-engineering/</link>
                <guid isPermaLink="false">682df55da72360814bcae9ef</guid>
                
                    <category>
                        <![CDATA[ vibe coding ]]>
                    </category>
                
                    <category>
                        <![CDATA[ AI Coding Assistant ]]>
                    </category>
                
                    <category>
                        <![CDATA[ AI ]]>
                    </category>
                
                    <category>
                        <![CDATA[ #ai-tools ]]>
                    </category>
                
                    <category>
                        <![CDATA[ software development ]]>
                    </category>
                
                    <category>
                        <![CDATA[ Software Engineering ]]>
                    </category>
                
                <dc:creator>
                    <![CDATA[ Ben ]]>
                </dc:creator>
                <pubDate>Wed, 21 May 2025 15:46:37 +0000</pubDate>
                <media:content url="https://cdn.hashnode.com/res/hashnode/image/upload/v1747835351675/3d178f26-c528-48b8-8ac2-32811a5672cf.png" medium="image" />
                <content:encoded>
                    <![CDATA[ <p>AI is disrupting all industries at a pace not seen at any time in history.</p>
<p>Technologies and industries that were once dominated by one or two companies or were very much “human-focused” are coming under threat.</p>
<p><a target="_blank" href="https://www.smoothseo.co/blog/misc/what-the-numbers-say-about-ais-growing-role-in-search/">Google is losing ground to AI search</a>, <a target="_blank" href="https://www.axios.com/2022/03/28/automation-long-haul-truckers-jobs">truck drivers</a> may soon be a thing of the past, and low-skilled clerical <a target="_blank" href="https://news.sky.com/story/ai-risks-up-to-eight-million-uk-job-losses-with-low-skilled-worst-hit-report-warns-13102214">jobs are being lost every day</a>.</p>
<p>Will this disruption destroy the Software Engineering industry? I don’t think so, and I’ll tell you why.</p>
<h3 id="heading-heres-what-well-discuss">Here’s what we’ll discuss:</h3>
<ol>
<li><p><a class="post-section-overview" href="#heading-the-phenomenon-of-vibe-coding">The Phenomenon of "Vibe Coding"</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-how-ai-has-changed-software-development">How AI Has Changed Software Development</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-the-productivity-paradox">The Productivity Paradox</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-why-human-engineers-are-still-critical">Why Human Engineers Are Still Critical</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-ai-as-a-capability-multiplier">AI as a “Capability Multiplier”</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-critical-skills-for-the-ai-era">Critical Skills for the AI Era</a></p>
</li>
<li><p><a class="post-section-overview" href="#heading-the-path-forward">The Path Forward</a></p>
</li>
</ol>
<h2 id="heading-the-phenomenon-of-vibe-coding"><strong>The Phenomenon of "Vibe Coding"</strong></h2>
<p>If you follow tech discussions on X, you've likely seen the term "vibe coding" – the practice of building software through trial and error, intuition, and AI-generated code snippets without deep technical knowledge.</p>
<p>Modern AI assistants such as GitHub Copilot and ChatGPT can generate full functions, fix bugs, and create components based on simple descriptions. “Vibe Coders” are claiming that human coders will soon become obsolete.</p>
<p>From my perspective, these AI tools function more as skill multipliers than replacements.</p>
<p>They help talented developers work faster while exposing gaps in knowledge for less skilled programmers. Those lacking technical foundations will face problems they can't solve, but engineers who blend AI assistance with solid expertise will be able to be incredibly productive.</p>
<h2 id="heading-how-ai-has-changed-software-development"><strong>How AI Has Changed Software Development</strong></h2>
<p>The software industry has seen rapid adoption of AI coding tools based on Large Language Models that analyze code repositories to predict and suggest next steps.</p>
<p>These tools have transformed daily programming work by:</p>
<ul>
<li><p>Suggesting complete functions as you type</p>
</li>
<li><p>Creating API endpoints from plain language descriptions</p>
</li>
<li><p>Eliminating hours spent on standard code patterns</p>
</li>
<li><p>Automating documentation tasks</p>
</li>
<li><p>Handling repetitive logic quickly</p>
</li>
</ul>
<p>This shift toward "vibe coding" speeds up feature delivery. Programmers can now build without mastering every technical detail – they describe what they want, get AI suggestions, and adjust until the code works.</p>
<p>The risk? Developers often push code they can't explain. They move quickly during building but struggle when systems break or need changing.</p>
<p>There's also a concerning trend of non-programmers selling AI-built applications. Recently, someone with zero coding background launched a paid service created entirely through AI prompts, only to face a data breach days later when hackers exploited basic security flaws. This is dangerous. It has wasted people's money and exposed their data. Imagine if this became common place due to the rise of “vibe coders”?</p>
<p>For anyone considering building software who isn’t a software engineer, there are a few basic levels of security that you need to consider:</p>
<ul>
<li><p>Adding authentication to your API endpoints: People can scan for open ports and endpoints across the internet. If they can then call your API endpoints without being authenticated, it can cause all sorts of problems</p>
</li>
<li><p>Do not store passwords in plain text. This is a big no no. If you do this and your database gets exposed, those passwords are there for all to see. And if we’re being real, people re-use passwords, so those passwords will be their passwords for other sites too.</p>
</li>
<li><p>SSL: Make sure your website is secure and has an up to date SSL certificate. Transmitting data in plain text is dangerous.</p>
</li>
<li><p>Lock down unused ports: If you are hosting a backend service, make sure that any ports that you don’t use are locked down and people aren’t able to connect to them.</p>
</li>
<li><p>If you have areas where people can upload files, limit the uploads to specific file types.</p>
</li>
</ul>
<p>Those are just a few considerations around security for your site or product, but there are many more.</p>
<h2 id="heading-the-productivity-paradox"><strong>The Productivity Paradox</strong></h2>
<p>AI assistance dramatically increases code output – but volume doesn't equal value in software engineering.</p>
<p>These tools excel at syntax but have no understanding about system architecture, scalability concerns, and maintenance requirements. Just as typing speed doesn't create a better novel, code generation speed doesn't produce better software systems.</p>
<p>AI works for individual functions but struggles with architectural decisions, security planning, and long-term support needs. Without proper review and understanding, AI-generated code often becomes tomorrow's tech-debt and maintenance burden.</p>
<p>Consider this scenario: A developer implements an AI-created authentication system that works in isolation but causes subtle failures in users signing up to the product. Finding and fixing these integration issues might take experienced staff several days – negating any initial time savings. This is a quick path to losing money and trust.</p>
<h2 id="heading-why-human-engineers-are-still-critical"><strong>Why Human Engineers Are Still Critical</strong></h2>
<p>While AI tools handle syntax well, they cannot:</p>
<ol>
<li><p>Plan systems that grow with user demand</p>
</li>
<li><p>Create reliable deployment and testing pipelines</p>
</li>
<li><p>Anticipate unusual but critical failure cases</p>
</li>
<li><p>Make smart tradeoffs between performance and cost</p>
</li>
<li><p>Find non-obvious security weaknesses</p>
</li>
</ol>
<p>Great engineers think beyond code. They develop patterns that help entire teams, select the right technologies, and plan both for success and failure scenarios.</p>
<p>Software creation involves complex tradeoffs: Do we prioritize speed or stability? Flexibility or simplicity? These decisions require both technical expertise and business knowledge.</p>
<p>The highest value engineers I work with spend more time thinking than typing. They consider: How will requirements evolve? What stress points might emerge? How will the system recover from failures?</p>
<p>As basic code generation becomes widely accessible, your value comes from understanding system interactions. The competitive edge will be with those who know why certain approaches succeed, where they might fail, and how to build resilient solutions.</p>
<p>Per the above, there are some things that AI without proper oversight can not do.</p>
<p>AI can, for instance, be great at passing simple prompts to create solutions to well known problems. If you use this prompt, for example:</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1747771377197/8aae1332-f852-435a-a724-a1770a4163bf.png" alt="Prompt: &quot;Create a Python module that will tell you if some input JSON is valid&quot;" class="image--center mx-auto" width="1024" height="130" loading="lazy"></p>
<p>Here’s the code you might get:</p>
<pre><code class="lang-python"><span class="hljs-keyword">import</span> json

<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">is_valid_json</span>(<span class="hljs-params">input_string: str</span>) -&gt; bool:</span>
    <span class="hljs-string">"""
    Checks if the input string is valid JSON.

    Args:
        input_string (str): The JSON string to validate.

    Returns:
        bool: True if valid, False otherwise.
    """</span>
    <span class="hljs-keyword">try</span>:
        json.loads(input_string)
        <span class="hljs-keyword">return</span> <span class="hljs-literal">True</span>
    <span class="hljs-keyword">except</span> json.JSONDecodeError:
        <span class="hljs-keyword">return</span> <span class="hljs-literal">False</span>

<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">main</span>():</span>
    user_input = input(<span class="hljs-string">"Enter a JSON string to validate: "</span>)
    <span class="hljs-keyword">if</span> is_valid_json(user_input):
        print(<span class="hljs-string">"✅ The input is valid JSON."</span>)
    <span class="hljs-keyword">else</span>:
        print(<span class="hljs-string">"❌ The input is NOT valid JSON."</span>)

<span class="hljs-keyword">if</span> __name__ == <span class="hljs-string">"__main__"</span>:
    main()
</code></pre>
<p>Pretty basic.</p>
<p>I would not, though, ask an AI to build me a complex Forex Trading platform.</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1747771546630/d212d814-7785-4391-8e01-79e80c05da44.png" alt="d212d814-7785-4391-8e01-79e80c05da44" class="image--center mx-auto" width="1368" height="212" loading="lazy"></p>
<p>I’ll save you reading through all of the response, but suffice it to say that it was not able to do this for me.</p>
<p>I thought I’d break that down to a slightly smaller subset of a financial trading platform:</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1747771773603/b65e1a13-97aa-4276-81c7-55303e5a04c6.png" alt="Prompt: &quot;Create me an endpoint for a FIX message for an FX Financial security. Make it in Python and I want to be able to accept J messages. Security is key here, so I need this to be as secure as possible.&quot;" class="image--center mx-auto" width="1326" height="224" loading="lazy"></p>
<p>Now, I will admit, this got closer. Here was the result:</p>
<pre><code class="lang-python"><span class="hljs-keyword">from</span> fastapi <span class="hljs-keyword">import</span> FastAPI, Request, HTTPException, Header
<span class="hljs-keyword">from</span> pydantic <span class="hljs-keyword">import</span> BaseModel, Field
<span class="hljs-keyword">from</span> typing <span class="hljs-keyword">import</span> Optional
<span class="hljs-keyword">import</span> hmac
<span class="hljs-keyword">import</span> hashlib
<span class="hljs-keyword">import</span> logging

app = FastAPI()

<span class="hljs-comment"># === CONFIGURATION ===</span>
SHARED_SECRET = <span class="hljs-string">b"super_secure_shared_secret"</span>  <span class="hljs-comment"># Keep this secure</span>

<span class="hljs-comment"># === LOGGING SETUP ===</span>
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(<span class="hljs-string">"ems.fix"</span>)

<span class="hljs-comment"># === Pydantic Model for Execution Report (simplified) ===</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">ExecutionReport</span>(<span class="hljs-params">BaseModel</span>):</span>
    msg_type: str = Field(default=<span class="hljs-string">"J"</span>, const=<span class="hljs-literal">True</span>)
    cl_ord_id: str  <span class="hljs-comment"># Tag 11</span>
    order_id: str   <span class="hljs-comment"># Tag 37</span>
    exec_id: str    <span class="hljs-comment"># Tag 17</span>
    exec_type: str  <span class="hljs-comment"># Tag 150</span>
    ord_status: str <span class="hljs-comment"># Tag 39</span>
    symbol: str     <span class="hljs-comment"># Tag 55 (e.g., EUR/USD)</span>
    side: str       <span class="hljs-comment"># Tag 54 (1=Buy, 2=Sell)</span>
    leaves_qty: float  <span class="hljs-comment"># Tag 151</span>
    cum_qty: float     <span class="hljs-comment"># Tag 14</span>
    avg_px: float      <span class="hljs-comment"># Tag 6</span>
    transact_time: str <span class="hljs-comment"># Tag 60 (ISO8601 string)</span>

<span class="hljs-comment"># === Helper: HMAC Validator ===</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">verify_signature</span>(<span class="hljs-params">payload: bytes, signature: str</span>) -&gt; bool:</span>
    computed = hmac.new(SHARED_SECRET, payload, hashlib.sha256).hexdigest()
    <span class="hljs-keyword">return</span> hmac.compare_digest(computed, signature)

<span class="hljs-comment"># === Endpoint ===</span>
<span class="hljs-meta">@app.post("/fix/execution-report")</span>
<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">receive_execution_report</span>(<span class="hljs-params">
    request: Request,
    x_signature: Optional[str] = Header(<span class="hljs-params">None</span>)
</span>):</span>
    body = <span class="hljs-keyword">await</span> request.body()

    <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> x_signature <span class="hljs-keyword">or</span> <span class="hljs-keyword">not</span> verify_signature(body, x_signature):
        logger.warning(<span class="hljs-string">"Invalid or missing signature."</span>)
        <span class="hljs-keyword">raise</span> HTTPException(status_code=<span class="hljs-number">403</span>, detail=<span class="hljs-string">"Unauthorized"</span>)

    <span class="hljs-keyword">try</span>:
        report_data = ExecutionReport.parse_raw(body)
        logger.info(<span class="hljs-string">f"Execution Report received: <span class="hljs-subst">{report_data.dict()}</span>"</span>)
        <span class="hljs-comment"># ✅ Here, you'd handle order updates, booking, etc.</span>
        <span class="hljs-keyword">return</span> {<span class="hljs-string">"status"</span>: <span class="hljs-string">"ok"</span>, <span class="hljs-string">"message"</span>: <span class="hljs-string">"Execution Report received"</span>}
    <span class="hljs-keyword">except</span> Exception <span class="hljs-keyword">as</span> e:
        logger.exception(<span class="hljs-string">"Invalid payload format."</span>)
        <span class="hljs-keyword">raise</span> HTTPException(status_code=<span class="hljs-number">400</span>, detail=<span class="hljs-string">f"Invalid FIX message format: <span class="hljs-subst">{str(e)}</span>"</span>)
</code></pre>
<p>But this does not come close to the final version. Even if you could use this code as a part of your trading system, unless you know how to build and architect and entire software system, where do you go from here? You can tell your clients that they can send you an “ExecutionReport”, but then what?</p>
<p>I’ve read and heard the arguments that you “just need to be better at prompting to build bigger systems”. But where does the benefit come from then? The complexity of financial trading systems is beyond comprehension. Prompting a system well enough, with enough information to make it fully featured, scalable, secure, and extensible (not to mention able to be debugged) would itself be a mammoth task. So where is the time being saved? Is it even possible?</p>
<p>I’m yet to see any proof anywhere that anyone has build such a complex system without the oversight of a human, and I’m not convinced we will see it at any point in the near future.</p>
<h2 id="heading-ai-as-a-capability-multiplier"><strong>AI as a “Capability Multiplier”</strong></h2>
<p>These AI tools help magnify existing capabilities rather than replacing them. Skilled developers become far more productive, while less skilled ones generate problems more quickly.</p>
<p>Effective engineers use AI to:</p>
<ul>
<li><p>Handle basic implementation tasks</p>
</li>
<li><p>Create initial project frameworks</p>
</li>
<li><p>Compare different solution approaches</p>
</li>
<li><p>Move past challenging problems</p>
</li>
</ul>
<p>Meanwhile, less capable developers use AI to mask skill gaps, implementing solutions they neither understand nor can modify. When these implementations fail, they lack the knowledge to fix them independently.</p>
<p>This widens the skill gap. Top engineers leverage AI for mechanical tasks while focusing on higher-value thinking. Those using AI as a substitute for learning face limitations when working beyond the AI's knowledge boundaries.</p>
<p>A good example of something that AI is perfect for is translation logic:</p>
<p>Let’s say I have Python Dataclass representing an" “InternalUser”. I also have a Django ORM representation of the same entity. If I wanted to convert one to the other, I can just paste both representations in to ChatGPT and get it create me a conversion function. Notice that the conversion function also takes into account that the field names aren’t exact matches:</p>
<pre><code class="lang-python"><span class="hljs-meta">@dataclass</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">InternalUser</span>:</span>
    id: str
    email: str
    hashed_password: str
    full_name: str
    role: UserRole
    status: AccountStatus
    created_at: datetime
    updated_at: datetime
    address: Optional[Address] = <span class="hljs-literal">None</span>
    preferences: Preferences = field(default_factory=Preferences)
    login_activity: LoginActivity = field(default_factory=LoginActivity)
    tags: List[str] = field(default_factory=list)
    notes: Optional[str] = <span class="hljs-literal">None</span>
</code></pre>
<pre><code class="lang-python"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">InternalUser</span>(<span class="hljs-params">models.Model</span>):</span>
    id = models.CharField(primary_key=<span class="hljs-literal">True</span>, max_length=<span class="hljs-number">100</span>)  <span class="hljs-comment"># Use UUIDField if preferred</span>
    email = models.EmailField(unique=<span class="hljs-literal">True</span>)
    hashedPassword = models.CharField(max_length=<span class="hljs-number">256</span>)
    fullName = models.CharField(max_length=<span class="hljs-number">255</span>)
    role = models.CharField(max_length=<span class="hljs-number">20</span>, choices=UserRole.choices, default=UserRole.USER)
    status = models.CharField(max_length=<span class="hljs-number">20</span>, choices=AccountStatus.choices, default=AccountStatus.PENDING)
    createdAt = models.DateTimeField(default=timezone.now)
    updatedAt = models.DateTimeField(auto_now=<span class="hljs-literal">True</span>)

    address = models.OneToOneField(Address, null=<span class="hljs-literal">True</span>, blank=<span class="hljs-literal">True</span>, on_delete=models.SET_NULL)
    preferences = models.OneToOneField(Preferences, on_delete=models.CASCADE)
    loginActivity = models.OneToOneField(LoginActivity, on_delete=models.CASCADE)

    tags = models.JSONField(default=list, blank=<span class="hljs-literal">True</span>)  <span class="hljs-comment"># List of strings</span>
    notes = models.TextField(null=<span class="hljs-literal">True</span>, blank=<span class="hljs-literal">True</span>)

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span>(<span class="hljs-params">self</span>):</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">f"<span class="hljs-subst">{self.fullName}</span> (<span class="hljs-subst">{self.email}</span>)"</span>
</code></pre>
<pre><code class="lang-python"><span class="hljs-keyword">from</span> typing <span class="hljs-keyword">import</span> Optional
<span class="hljs-keyword">from</span> myapp.models <span class="hljs-keyword">import</span> InternalUser <span class="hljs-keyword">as</span> ORMInternalUser, Address <span class="hljs-keyword">as</span> ORMAddress, Preferences <span class="hljs-keyword">as</span> ORMPreferences, LoginActivity <span class="hljs-keyword">as</span> ORMLoginActivity
<span class="hljs-keyword">from</span> mydataclasses <span class="hljs-keyword">import</span> InternalUser <span class="hljs-keyword">as</span> DCInternalUser  <span class="hljs-comment"># assuming your dataclass lives here</span>


<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">convert_internal_user_to_model</span>(<span class="hljs-params">dc_user: DCInternalUser</span>) -&gt; ORMInternalUser:</span>
    <span class="hljs-comment"># Create or update Address if provided</span>
    orm_address: Optional[ORMAddress] = <span class="hljs-literal">None</span>
    <span class="hljs-keyword">if</span> dc_user.address:
        orm_address = ORMAddress.objects.create(
            street=dc_user.address.street,
            city=dc_user.address.city,
            state=dc_user.address.state,
            postalCode=dc_user.address.postal_code,
            country=dc_user.address.country
        )

    <span class="hljs-comment"># Create Preferences</span>
    orm_preferences = ORMPreferences.objects.create(
        newsletterOptIn=dc_user.preferences.newsletter_opt_in,
        darkModeEnabled=dc_user.preferences.dark_mode_enabled,
        language=dc_user.preferences.language
    )

    <span class="hljs-comment"># Create LoginActivity</span>
    orm_login_activity = ORMLoginActivity.objects.create(
        lastLogin=dc_user.login_activity.last_login,
        loginAttempts=dc_user.login_activity.login_attempts,
        lastIpAddress=dc_user.login_activity.last_ip_address
    )

    <span class="hljs-comment"># Create InternalUser</span>
    orm_user = ORMInternalUser.objects.create(
        id=dc_user.id,
        email=dc_user.email,
        hashedPassword=dc_user.hashed_password,
        fullName=dc_user.full_name,
        role=dc_user.role.value,
        status=dc_user.status.value,
        createdAt=dc_user.created_at,
        updatedAt=dc_user.updated_at,
        address=orm_address,
        preferences=orm_preferences,
        loginActivity=orm_login_activity,
        tags=dc_user.tags,
        notes=dc_user.notes
    )

    <span class="hljs-keyword">return</span> orm_user
</code></pre>
<p>This is a basic example, but extrapolate this out to an entire internal data model and you’ve saved hours and hours of code.</p>
<p>You can even then ask it to create you the function stubs of the tests:</p>
<pre><code class="lang-python"><span class="hljs-keyword">import</span> pytest
<span class="hljs-keyword">from</span> datetime <span class="hljs-keyword">import</span> datetime
<span class="hljs-keyword">from</span> yourmodule.dataclasses <span class="hljs-keyword">import</span> InternalUser, Address, Preferences, LoginActivity, UserRole, AccountStatus
<span class="hljs-keyword">from</span> yourmodule.conversion <span class="hljs-keyword">import</span> dataclass_to_django_internal_user


<span class="hljs-meta">@pytest.mark.django_db</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">test_internal_user_conversion_basic_fields</span>():</span>
    <span class="hljs-comment"># Test that basic fields (email, name, etc.) are correctly copied</span>
    <span class="hljs-keyword">pass</span>


<span class="hljs-meta">@pytest.mark.django_db</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">test_internal_user_conversion_with_address</span>():</span>
    <span class="hljs-comment"># Test that address fields are properly mapped to the ORM model</span>
    <span class="hljs-keyword">pass</span>


<span class="hljs-meta">@pytest.mark.django_db</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">test_internal_user_conversion_with_preferences</span>():</span>
    <span class="hljs-comment"># Test preferences like dark mode, newsletter opt-in, and language</span>
    <span class="hljs-keyword">pass</span>


<span class="hljs-meta">@pytest.mark.django_db</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">test_internal_user_conversion_with_login_activity</span>():</span>
    <span class="hljs-comment"># Test login attempts, last IP, and last login datetime</span>
    <span class="hljs-keyword">pass</span>


<span class="hljs-meta">@pytest.mark.django_db</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">test_internal_user_conversion_with_tags_and_notes</span>():</span>
    <span class="hljs-comment"># Test tags list and optional notes field</span>
    <span class="hljs-keyword">pass</span>


<span class="hljs-meta">@pytest.mark.django_db</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">test_internal_user_conversion_with_missing_optional_fields</span>():</span>
    <span class="hljs-comment"># Ensure None fields like address or lastLogin don’t break conversion</span>
    <span class="hljs-keyword">pass</span>


<span class="hljs-meta">@pytest.mark.django_db</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">test_internal_user_conversion_saves_correctly</span>():</span>
    <span class="hljs-comment"># Save all related models and main InternalUser model and check database</span>
    <span class="hljs-keyword">pass</span>
</code></pre>
<p>Now, I’m not suggesting that you take these as is and don’t add your own thought in to each possible test scenario, but it’s a great start.</p>
<p>These pieces of “grunt work” were never what we paid the top engineers for. These were just the things that they had to do to get the job done. People didn’t enjoy these tasks. They weren’t fulfilling.</p>
<h2 id="heading-critical-skills-for-the-ai-era"><strong>Critical Skills for the AI Era</strong></h2>
<p>As AI handles more coding tasks, successful engineers must develop strengths in areas where human judgment remains essential:</p>
<p>Systems thinking becomes the primary skill – understanding component interactions, identifying potential failures, and designing for future growth. This capability comes from experience, not prompting.</p>
<p>You should build expertise in infrastructure and deployment processes. Software that works in development but fails in production creates no value. So, learn about <a target="_blank" href="https://www.freecodecamp.org/news/learn-continuous-integration-delivery-and-deployment/">continuous integration</a>, <a target="_blank" href="https://www.freecodecamp.org/news/how-to-set-up-monitoring-for-nodejs-applications-using-elastic/">monitoring</a> systems, and <a target="_blank" href="https://www.freecodecamp.org/news/beginners-guide-to-cloud-computing-with-aws/">cloud platform capabilities</a>.</p>
<p>You should also master <a target="_blank" href="https://www.freecodecamp.org/news/rest-api-design-best-practices-build-a-rest-api/">API design</a> – the interfaces between systems. <a target="_blank" href="https://www.freecodecamp.org/news/design-an-api-application-program-interface/">Well-designed APIs</a> enable team independence. Poor interfaces create bottlenecks affecting everyone.</p>
<p>Another key skill is being able to integrate security throughout the development process. A single oversight can result in breaches, damaging both customer trust and business standing.</p>
<p>Make sure you develop communication skills for both technical and non-technical audiences. You’ll need to explain complex decisions clearly across different stakeholder groups.</p>
<p>And study how AI tools function to understand their limitations and strengths, allowing you to use them most effectively.</p>
<p>For senior developers, mentoring becomes increasingly important. New engineers need guidance on responsible AI usage – knowing when to accept suggestions and when to question them.</p>
<h2 id="heading-the-path-forward"><strong>The Path Forward</strong></h2>
<p>The software field is entering a significant transition. AI will generate more code more quickly, transforming development practices. This shift presents both opportunities and challenges.</p>
<p>The most valuable positions will go to those good at tasks machines cannot handle. These engineers will determine what to build, how to design it, and how to balance technical constraints with business objectives.</p>
<p>"Vibe coding" serves as a useful technique for specific needs – like quickly building standard components. But it fails as a comprehensive strategy for complex system development.</p>
<p>Skilled engineers will advance by delegating routine work to AI while addressing more challenging problems. Less skilled engineers will struggle as fundamental knowledge gaps become apparent.</p>
<p>With regards to learning how to use AI effectively, also use caution and judgement when following advice from people online. It’s still a fairly new field and changes constantly.</p>
<p>People online are giving away “free prompts” to generate code. These prompts may be great or may have problems. The prompts may have worked when they used them, but the AI models may have changed and maybe they’ll produce different results now. Be cautious and use your best judgement.</p>
<p>The future belongs to those who view AI as a collaborative tool rather than a replacement. Software development remains fundamentally human-driven, now supported by increasingly powerful assistance.</p>
<p><em>In his spare time, Ben writes his tech blog</em> <a target="_blank" href="https://justanothertechlead.com/"><em>Just Another Tech Lead</em></a> <em>and runs a site on SEO,</em> <a target="_blank" href="https://www.smoothseo.co"><em>SmoothSEO</em></a><em>.</em></p>
 ]]>
                </content:encoded>
            </item>
        
    </channel>
</rss>
