There’s a fear running through every industry right now: AI is coming for my job.

Writers, designers, coders—they’re all worried about ChatGPT and Claude. Especially when a new model drops and demonstrates capabilities that seemed impossible six months ago. Each release ratchets up the anxiety: How long until this thing can do what I do?

But after a year of building heavily with these tools, I think this framing misses the point entirely.

AI isn’t replacing jobs. It’s replacing how jobs get done.

And the skill that’s emerging as universal? AI Engineering.

“The Hottest New Programming Language Is English”

Andrej Karpathy—former Tesla AI Director, OpenAI founding member—put it perfectly:

“The hottest new programming language is English.”

This isn’t a joke. It’s the new reality.

The ability to clearly articulate intent, break down problems, and iterate on AI outputs is becoming the core competency across every role. Whether you’re deploying infrastructure or designing a logo, the workflow is the same: define intent, prompt the system, validate the output, iterate.

That’s engineering. And everyone is doing it now.

What “AI Engineering” Actually Looks Like

Let me make this concrete with examples from my own work.

Cloud & DevOps → Prompt Engineering

In The Speed of AI-Assisted Development, I fixed a Python Lambda function, debugged a GitHub Actions pipeline, and deployed a new frontend—all in under an hour. I didn’t write the MIME parsing logic or look up the S3 CLI flags. I described what I needed. The agent wrote the code.

When I consolidated my domains using CloudFront Functions, I didn’t memorize the request.headers.host.value syntax. I defined the architecture—“redirect these hosts to this target with a 301”—and engineered the prompt to get working code.

The engineering wasn’t typing. The engineering was:

• Choosing the right architecture (CloudFront Function vs. S3 redirect buckets)
• Validating the AI’s logic against edge cases
• Orchestrating the deployment

Content Creation → Prompt Engineering

When I write for this blog, I’m often acting as an editor-in-chief for an AI staff writer. I provide structure, context, and voice. The AI drafts. I refine.

When I need visuals, I don’t open Photoshop. As I explored in AI Image Generation, I engineer the prompt—tweaking negative prompts, adjusting seeds, iterating until the output matches my vision.

Same discipline. Different domain.

Every Role Is Becoming AI Engineering

Think about what’s actually happening across industries:

The job titles may stay the same. But the core skill is converging: the ability to effectively collaborate with AI systems.

That’s AI Engineering.

The Question That Matters Now

As I wrote earlier today in Ask Better Questions or Get Left Behind, Jensen Huang’s advice cuts through the noise:

“How does AI help me do my job better?”

Not hypothetically. Not someday. Today. In your role.

The people who keep asking that question—and keep refining their ability to work with AI—are the ones building leverage. Everyone else is just using a smarter Google.

The Human Stays in the Loop

Does this mean humans become irrelevant? No. As I discussed in Humans in the Loop in the AI Era, this shift makes human oversight more strategic, not less.

When AI handles execution, humans provide:

1. Judgment — Is this output correct? Appropriate? Good?
2. Context — What’s the real problem we’re solving?
3. Direction — Where should we go next?

AI isn’t replacing your job. It’s promoting you to Lead Engineer of your own AI workforce.

Final Thought

The hottest programming language is English.
The emerging universal skill is AI Engineering.

And the question isn’t whether AI will change your job.
It’s whether you’ll learn to engineer with it—or get left behind.

Jensen Huang on Using AI Early in Your Career

“The people who stand out aren’t the ones asking AI random questions, they’re the ones asking how AI helps them do their job better.”
— Jensen Huang, CEO of NVIDIA

That line hits harder in today’s market than it would have a few years ago.

Right now, unemployment for ages 20–24 has jumped to ~9.2%, a level usually seen during recessions. New grads are competing in a market where credentials matter less and leverage matters more.

AI isn’t the advantage by itself.
Knowing what to ask is.

The Wrong Way to Use AI (Most People Are Here)

Most people treat AI like:

• A smarter Google
• A code generator
• A homework helper
• A content writer

So they ask:

• “Explain Kubernetes”
• “Write this function”
• “Summarize this article”
• “Make me a resume”

That might save time.
It does not create leverage.

The Right Question (The One Jensen Is Pointing At)

Instead of asking:

“What can AI do?”

Ask this, persistently:

“How does AI help me do my job better?”

Not hypothetically.
Not someday.
Today. In my role.

That single question reframes AI from a tool into a multiplier.

The Question, Applied to You

Here’s how that question looks when you actually operationalize it.

If You’re a Student or New Grad

Wrong question:
“Can AI explain this topic?”

Better question:
“How can AI help me learn this faster than everyone else?”

Best question:
“How can AI help me build proof that I can already do this job?”

Concrete uses:

• Turn lectures → interview-ready explanations
• Convert assignments → portfolio artifacts
• Simulate interviews weekly
• Build tiny demos instead of just studying

Outcome:
You stop competing on GPA and start competing on evidence.

If You’re an Engineer

Wrong question:
“Can AI write this code?”

Better question:
“How can AI help me ship higher-quality systems faster?”

Best question:
“How can AI turn me from a ticket-closer into a systems thinker?”

Concrete uses:

• Pre-think designs before reviews
• Generate test strategies & edge cases
• Turn vague tasks into clear plans
• Document decisions and tradeoffs

Outcome:
You look senior earlier, because you think in systems, not snippets.

If You’re a Manager / SDM

Wrong question:
“Can AI help me write emails?”

Better question:
“How can AI help me lead people better?”

Best question:
“How can AI multiply my impact across people, projects, and stakeholders?”

Concrete uses:

• Draft clear feedback (especially hard feedback)
• Prepare for tough conversations
• Translate strategy → execution plans
• Produce crisp weekly updates that build trust

Outcome:
Less chaos. More clarity. Higher trust.

If You’re a Builder or Founder

Wrong question:
“What startup ideas does AI have?”

Better question:
“How can AI help me validate ideas faster?”

Best question:
“How can AI compress learning loops so I fail or win quickly?”

Concrete uses:

• Write landing pages in minutes
• Simulate customer objections
• Generate outreach messages
• Scope MVPs aggressively small

Outcome:
You test markets, not fantasies.

The Meta-Question (This Is the Cheat Code)

No matter your role, the question always reduces to this:

“If I keep asking AI better questions than everyone else, what compounds for me in 12 months?”

• Better judgment
• Faster execution
• Stronger communication
• Sharper intuition
• More optionality

AI rewards clarity of intent, not curiosity alone.

Why This Matters Right Now

In a weak job market:

• Average effort doesn’t stand out
• Credentials decay faster
• Titles matter less than output

AI creates a brutal divide:

1. People who use it to think
2. People who use it to ask

Jensen Huang’s advice isn’t about prompts.
It’s about ownership of your trajectory.

Final Takeaway

Don’t ask AI to replace your work.

Ask AI to:

• sharpen your thinking
• compress your learning
• multiply your impact
• leave artifacts behind

The people who win won’t be the ones who used AI the most.

They’ll be the ones who asked the right question early,
and kept asking it every day.

When I decided to revamp my blog, I wanted a setup that was fast, cost-effective, and easy to maintain. But more importantly, I wanted to experiment with a fully AI-assisted development workflow.

This blog isn’t just hosted on the cloud—it is maintained and evolved by an AI Agent.

The Core Stack

I chose a static site architecture for its speed and security.

• Engine: Hexo, a fast and simple static site generator based on Node.js.
• Theme: Icarus, giving it that clean, professional look.
• Storage: AWS S3 buckets to host the static HTML/CSS/JS files.
• Delivery: AWS CloudFront (CDN) to serve content globally with low latency and SSL.
• DNS: Amazon Route53 for domain management.

This “Serverless” setup costs practically nothing to run and scales infinitely.

The AI-First Workflow

The most interesting part isn’t the stack itself, but how it represents a new way of working. I use Google’s Antigravity, an advanced AI coding agent, to drive the development and maintenance.

Instead of manually editing config files or searching for plugins, I simply conversed with the agent:

“Implement a Sitemap and RSS feed.”
“Fix the domain verification issue.”
“Generate cover images for all my posts.”

The agent analyzed my project structure, installed the necessary plugins (hexo-generator-sitemap, hexo-generator-feed), and updated the _config.yml automatically.

AI-Generated Art

You might have noticed that every post on this blog has a unique cover image. These weren’t found on stock photo sites—they were generated on the fly by the agent using Google’s Gemini 3 Pro. I simply asked it to “scan my posts and generate relevant images,” and it handled the rest.

SEO & Discovery

To ensure this content reaches you, we implemented standard best practices:

1. Sitemap: Automatically generated at /sitemap.xml for search engines.
2. RSS Feed: Available at /atom.xml (link in the sidebar!) for subscribers.
3. Performance: Minified assets and edge caching. We enabled hexo-all-minifier which reduced the total site build size from 20MB to 10MB (a 50% reduction!) primarily through intelligent image optimization. Then we further optimized by converting heavy images to WebP!

Conclusion

Building this blog was a testament to how AI agents are changing software development. We moved from concept to a fully polished, SEO-optimized, and visually rich site in a fraction of the time it would normally take.

Stay tuned for more updates on AI, Cloud, and the future of coding.

I recently consolidated my two separate blogs (ai.saurav.io and cloud.saurav.io) into a single unified home: blog.saurav.io.

While moving the markdown files was easy, the networking challenge took a bit more finesse. I needed to ensure that visitors (and search engines) visiting the old domains were automatically redirected to the new one, verifying path preservation.

Here is how I solved it using CloudFront Functions.

The Architecture

Instead of maintaining separate CloudFront distributions or S3 buckets for redirection—which is the “old school” way—I pointed all domains to a single CloudFront distribution and handled the routing logic at the edge.

1. CloudFront: Added ai.saurav.io, cloud.saurav.io, and blog.saurav.io as aliases (CNAMEs) to my main distribution.
2. DNS: Updated Route53 to point all three domains to that distribution.
3. Edge Logic: Attached a CloudFront Function to the Viewer Request event.

The CloudFront Function

CloudFront Functions are lightweight Javascript functions that run at AWS edge locations. They are perfect for header manipulation and URL redirects because they have extremely low latency and cost.

Here is the function code I used to force the redirect:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

function handler(event) {
    var request = event.request;
    var host = request.headers.host.value;
    var uri = request.uri;

    // Check if the request is coming from one of the old domains
    if (host === 'ai.saurav.io' || host === 'cloud.saurav.io') {
        return {
            statusCode: 301,
            statusDescription: 'Moved Permanently',
            headers: {
                "location": { "value": "https://blog.saurav.io" + uri }
            }
        };
    }

    // Otherwise, let the request proceed to the origin (S3)
    return request;
}

Why Not Just “Point” the Domains?

A common question is: “Why can’t I just add the CNAMEs to CloudFront and be done with it?”
Technically, that would serve the content. If a visitor accesses ai.saurav.io, they would see the blog. But serving content and managing identity are two different things.

Here is the critical difference between “Just Pointing” (CNAME only) vs. “Redirecting” (CloudFront Function):

Why This Approach Matches Modern Architecture

The only non-code way to achieve this would be to create three separate S3 buckets (one for content, two empty ones for redirects) and potentially separate CloudFront distributions for each.

By using a CloudFront Function, I kept the infrastructure minimal:

• 1 S3 Bucket
• 1 CloudFront Distribution
• 1 Function

This approach is cleaner, easier to maintain, and ensures that my diverse technical interests in AI and Cloud are finally unified under one roof.

Built with AI

This entire migration—from identifying the conflicting aliases, writing the Python scripts, to authoring this blog post—was planned and executed using Antigravity IDE and the Google Gemini 3 Pro model. The agent figured out the complex steps, and I simply validated the plan. It turns hours of DevOps work into single commands.

I’ve been experimenting with AI coding agents recently, and the speed at which I can move between different layers of the stack is mind-blowing. Today, I sat down with an AI agent (Google Antigravity in my case but can be any like Cursor or Claude Code) to tackle a laundry list of tasks that would normally take me half a day. We finished them in under an hour.

Here’s a breakdown of the “flow” and what we accomplished in a single session.

1. Fixing Legacy Code (Python/AWS Lambda)

I started with a bug in the email forwarder for cloudyeti.io, my personal cloud project. It was sending emails as attachments instead of inline text.

• The Task: Modify a Python Lambda function to parse MIME parts and reconstruct the email body.
• The AI’s Role: I didn’t have to look up the email.message library docs or remember how to traverse multipart payloads. The agent just wrote the code, zipped it, and updated the Lambda function.

2. Debugging CI/CD Pipelines (GitHub Actions)

Next, I switched context completely to blog.bipratech.com, a site for my dad’s company. The deployment workflow was stuck.

• The Fix: The agent identified we were using an old macOS runner and switched it to ubuntu-latest. It also fixed a subtle S3 bucket naming error and removed a deprecated ACL flag that was causing the build to fail.
• The Result: A green build and a successful deployment to CloudFront.

3. Frontend & Design (Saurav.io)

Then came the creative part. I wanted a new, sleek portfolio for saurav.io.

• The Build: I gave the agent a rough idea (“minimalist, dark mode, sleek”). It generated a single-page HTML/CSS site with a premium feel, “Inter” typography, and a responsive design.
• The Deployment: We synced it to S3 and invalidated the CloudFront cache.
• The “Oops” Moment: I realized the site wasn’t updating. The agent investigated Route53, found that saurav.io was actually pointing to a different S3 bucket (sauravsharma.net), and corrected the deployment target instantly.

4. Rapid Iteration

Finally, I wanted to tweak the content—remove the fluff, keep it minimal (“Cloud Technologist • AI Builder • Indie Musician”), and add a profile picture.

• The Speed: These changes happened in seconds. No context switching, no “where is that file again?”, no “what’s the CSS for a circular image?”. Just intent -> execution.

The Takeaway

Tools like Google Antigravity, Cursor, and Claude Code aren’t just “autofill” anymore. They are context-aware collaborators. They allow me to be a “Cloud Engineer” one minute, a “DevOps Engineer” the next, and a “Frontend Designer” right after.

The bottleneck is no longer writing the code; it’s having the clarity of what you want to build. When you have that, the AI handles the rest.

At their respective peaks, AI hype is likely higher than cloud hype, primarily due to the following factors:

1. Broader Public Awareness

• Cloud Hype (2010s): While the cloud revolutionized IT and business operations, its hype was more confined to tech-savvy audiences, enterprises, and investors. Everyday consumers indirectly benefited (e.g., through apps like Netflix or Dropbox), but they didn’t deeply engage with the concept.
• AI Hype (2020s): AI directly engages the public. Tools like ChatGPT, MidJourney, and DALL·E have reached millions of non-technical users, creating a cultural impact that extends beyond the tech world.

2. Immediate User Impact

• Cloud Computing: Delivered operational and cost advantages primarily for businesses (e.g., scalable infrastructure, SaaS). For end-users, its effects were indirect.
• AI: Offers tangible, personal utility—content creation, coding help, art generation, personalized recommendations—leading to stronger hype among individuals.

3. Media & Speculation

• Cloud: The conversation was heavily focused on B2B transformations and tech investments.
• AI: AI stirs debates about existential risks, societal impacts, and philosophical questions, grabbing broader headlines. The sheer excitement (and fear) surrounding AI’s potential future (e.g., AGI) amplifies the hype.

4. Financial Backing and Market Size

• Cloud (2010s): Cloud computing was massive and continues to grow, but much of the excitement was tied to its enterprise applications.
• AI (2020s): AI investments now span every sector (healthcare, finance, creative arts, education). The venture capital poured into AI startups in a single year (e.g., 2023-24) has outpaced funding for cloud in its earlier growth phase.

In Conclusion

While cloud hype laid the foundation for AI to flourish, AI has reached a broader cultural, technological, and economic peak of hype. However, AI hype may also burn faster if real-world applications don’t meet expectations or if challenges (e.g., ethical concerns, regulation) slow growth.

Disclaimer: This response was generated by AI based on the prompt: “Cloud hype vs AI hype, which is higher at peak?”

I’ve used many AI tools and apps so far. I’ve also built AI apps at work and as side projects. Some of these apps have great UX and I tend to go back to use it. Some don’t and I do not want to go back. It may seem like an obvious observation, but having a good UX is very important for AI tools.

Also, AI tools and software builders have the opportunity to differentiate themselves by experimenting with new flows and UX.

I’m seeing massive potential in Human-in-the-Loop (HITL) workflows as AI agents become more sophisticated. With specialized agents handling everything from code analysis to content generation, human oversight is evolving into a strategic advantage rather than just a safety check.

The magic happens in the feedback loop - humans refining AI outputs, which in turn makes the AI better at understanding human intent. I’ve found this particularly powerful in development workflows, where HITL systems help catch edge cases and maintain quality while significantly speeding up delivery.

As we move towards multi-agent systems working in concert, I believe HITL will become the key differentiator. It’s not just about having AI capabilities anymore - it’s about effectively partnering with AI to amplify what humans do best: providing context, judgment, and creative direction.

Written on December 7, 2024

#HITL #AIAgents #FutureOfWork

AI Agents are now becoming a thing, where an LLM based AI agent with instruction performs a tasks. There are several examples of AI agents which are already very impressive.

Soon there will be Trillions of AI agents on the web doing stuff. It’s gonna get chaotic but interesting.

August 11, 2023

My go-to method for initiating a new personal project is an innovative combination of the Serverless Framework[1] and ChatGPT. This powerful blend enables me to describe my project requirements using natural language and quickly receive a stack of resources necessary for my web application.

For example, all I had to say was:

“Give me a Serverless Framework YAML file to create an API endpoint to get/put an item in a DynamoDB using a Python-based Lambda.”

This wasn’t just a command; it was a powerful instruction that resulted in the following output:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

service: my-dynamodb-service

provider:
  name: aws
  runtime: python3.8
  region: us-east-1
  iamRoleStatements:
    - Effect: Allow
      Action:
        - dynamodb:GetItem
        - dynamodb:PutItem
      Resource: "arn:aws:dynamodb:${opt:region, self:provider.region}:*:table/MyTable"

functions:
  getItem:
    handler: handler.getItem
    events:
      - http:
          path: item/{id}
          method: get
          cors: true

  putItem:
    handler: handler.putItem
    events:
      - http:
          path: item
          method: put
          cors: true

resources:
  Resources:
    MyTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: MyTable
        AttributeDefinitions:
          - AttributeName: id
            AttributeType: S
        KeySchema:
          - AttributeName: id
            KeyType: HASH
        ProvisionedThroughput:
          ReadCapacityUnits: 5
          WriteCapacityUnits: 5

Thrilled with the result, I asked again:

“Give me the Python handler file and instructions to deploy this.”

The response was equally prompt and effective:

Create Python Handlers

Create two Python functions in a file named handler.py. These functions will correspond to the getItem and putItem Lambda functions defined in the YAML file.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import boto3
import json

# DynamoDB client
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('MyTable')

def getItem(event, context):
    item_id = event['pathParameters']['id']
    response = table.get_item(Key={'id': item_id})
    return {
        'statusCode': 200,
        'body': json.dumps(response['Item'])
    }

def putItem(event, context):
    item = json.loads(event['body'])
    table.put_item(Item=item)
    return {
        'statusCode': 200,
        'body': json.dumps({'message': 'Item inserted successfully'})
    }

Directory Structure

Ensure that your directory structure looks like this:

1
2
3

project-root/
|-- handler.py
|-- serverless.yml (your YAML configuration)

Deploying the Service

Navigate to your project root directory and run the following command:

1

serverless deploy

This command packages and deploys your service, including the Lambda functions and the DynamoDB table.

The collaboration between the Serverless Framework and ChatGPT simplifies the development process, converting ideas into ready-to-deploy code with ease. It’s a practical change in how I tackle personal projects, aligning innovative thinking with contemporary cloud tools.

[1]: Serverless Framework: https://www.serverless.com/