AI in Coding: Demystifying Nuance from Personal Experience

Introduction

In my previous article, AI as Your Lead Engineer, I shared an experiment where AI took the role of a lead engineer, guiding me through building a FastAPI app without writing a single line of code myself. Today, I want to address some widespread concerns: Will AI eliminate coding jobs? Is AI just another hype?

If you are a business person or investor who has not been hands-on for a while, this article can give you some first-hands viewpoint; if you are an engineer who has felt uncertain or overwhelmed by the recent AI advancements and news, this article can help ease your concerns and may serve as a starting point to embrace the AI era of software engineering.

AI Won't Eliminate Coding Jobs—It Will Transform Them

One of the biggest fears / hypes surrounding AI is that it will replace human coders altogether. From my experience, however, the reality is more nuanced. AI isn’t making coding jobs obsolete; rather, it’s redefining what it means to be a software engineer.

Recently, I used AI to build a testable DynamoDB + OpenSearch serverless microservice. The AI helped me generate both component-level tests using moto and microservice-level end-to-end tests using localstack. It did this in record time, and I was amazed at how productive I became. Here is a piece of code snippet I’d like to share — note: I did not write a single line of code, all code are generated by AI.

import boto3
import requests
import json
from localstack.utils.aws import aws_stack
import time

def test_end_to_end():
    # Setup DynamoDB
    dynamodb = boto3.client('dynamodb', region_name='us-east-1', endpoint_url='http://localhost:4566')
    dynamodb.create_table(
        TableName='shop-items',
        KeySchema=[{'AttributeName': 'item_id', 'KeyType': 'HASH'}],
        AttributeDefinitions=[{'AttributeName': 'item_id', 'AttributeType': 'S'}],
        BillingMode='PAY_PER_REQUEST'
    )

    # Setup SQS
    sqs = boto3.client('sqs', region_name='us-east-1', endpoint_url='http://localhost:4566')
    queue_url = sqs.create_queue(QueueName='test-queue')['QueueUrl']

    # Setup OpenSearch (assume it's running locally in the localstack container)
    opensearch_url = 'http://localhost:4566'
    requests.put(f'{opensearch_url}/items')

    # Test API Gateway -> Lambda -> DynamoDB -> SQS -> Lambda -> OpenSearch flow
    # 1. Insert an item
    item_data = {
        "item_id": "123",
        "item_name": "Test Item",
        "item_description": "Test Description"
    }
    response = requests.post('http://localhost:4566/restapis/xxxxxx/dev/_user_request_/items/', json=item_data)
    assert response.status_code == 200

    # Give some time for processing (optional, depending on how asynchronous your process is)
    time.sleep(2)

    # 2. Verify item in DynamoDB
    response = dynamodb.get_item(TableName='shop-items', Key={'item_id': {'S': '123'}})
    assert 'Item' in response

    # 3. Verify SQS message received
    messages = sqs.receive_message(QueueUrl=queue_url)
    assert 'Messages' in messages

    # 4. Verify item indexed in OpenSearch
    search_response = requests.get(f'{opensearch_url}/items/_search?q=Test')
    assert search_response.status_code == 200
    search_results = search_response.json()
    assert len(search_results['hits']['hits']) > 0

But here’s the thing: AI didn’t make me redundant—it made me more valuable. While the AI was great at generating code, it wasn’t perfect (at least not yet). It needed guidance, especially in nuanced decisions like choosing the right tools. For example, I had to instruct the AI to use Poetry for dependency management — otherwise, I won’t be building a project that I’d like to maintain and take ownership on. And when AI produced incomplete or inaccurate results, it was my responsibility to catch and correct those errors — in this sense, I still need to be responsible to guide the AI engineer toward the right direction.

In short, AI is not here to take away jobs but to change the skills required. Engineers who can effectively work alongside AI will be indispensable. While AI might reduce the number of traditional coding positions, it will also create new opportunities for engineers who can leverage these tools to add even more value.

AI Is Not Just a Hype—It’s a Tangible Productivity Booster

Lately though, I heard people started some kind of skepticism that AI is overhyped. From my hands-on experience, nothing could be further from the truth. The productivity boost I've experienced since incorporating AI into my workflow has been transformational.

Take the same serverless microservice project as an example. Without AI, it would have taken me days, if not weeks, to write and test the code. With AI, I accomplished it in a fraction of the time. AI has undeniably boosted my productivity by 10x.

However, this boost doesn’t come without effort. To truly benefit from AI, you need to be specific in your prompts, understand the tools and frameworks ahead of time, and be ready to spot and correct mistakes the AI makes. It’s a new way of working, requiring a different mindset and new skills.

A more detailed project that AI generated end to end

The above code snippet illustrated how AI has helped me to tame a challenging problem for serverless architecture based development: how to write tests as we do traditional paradigm based software development. But I only shared some code snippet. Here I’d like to share a complete project, which I spent $1.2 to build.

If you wanted to start a FastAPI project, this repo is a repo generate by Claude could be your skeleton FastAPI project for FastAPI app starters, just like the create-react-app to React app starters — I did not write a single line of code, but it can get you started with building your FastAPI backend.

What Does This Mean for the Future of Software Engineering?

So, what does all this mean for the future of software engineering? While AI will certainly change the landscape, it’s not something to fear. Instead, it’s an opportunity for us to evolve as engineers. Companies that can harness AI in tangible ways will thrive in this new era. And as engineers, our role will shift from writing code to orchestrating complex systems and guiding AI to produce the best possible results. The true problem solvers are needed more.

Conclusion

In conclusion, AI is not here to replace engineers but to empower them — overtime, we may change the title of “software engineer” into “problem-solver-with-code”. The engineers of the future will not be those who can only write code but those who can combine their coding skills with the power of AI to solve complex problems more efficiently than ever before.

If you're interested in exploring how AI can enhance your engineering workflows or curious about the new skill sets that will be essential in this AI-driven world from practitioners viewpoint, I encourage you to subscribe and stay tuned for more insights. Let’s navigate this evolving landscape together.