# From Software Developer to AI Engineer

Antje Barth · Mike Chambers

AI Engineer World's Fair 2024

[Talk page](https://ai.engineer/talks/90Ir4TMMbS0-from-software-developer-ai-engineer) · [Video](https://www.youtube.com/watch?v=90Ir4TMMbS0)

## From Software Developer to AI Engineer

Build on software engineering skills by learning model behavior, using AI development tools, testing models through a common API, and composing tools into agent workflows.

Familiarity with application development, APIs, and basic Python will help with the examples; no machine learning research background is required.

### Learn what sits behind the API

[0:36](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=36s)

If an AI application can begin with a few API calls, what does a software developer still need to learn? The opening role diagram places AI engineering on the application side of the API boundary. The role associated with swyx’s [The Rise of the AI Engineer](https://www.latent.space/p/ai-engineer) makes room for developers who build with models without becoming ML researchers or data scientists first. Access to a model removes a substantial barrier to getting started.

![Diagram places ML research and engineering left of an API divider, with AI engineering and fullstack engineering to the right.](https://ai.engineer/api/talk-essay-media/16fa8ec1d8072e296d47b70cf9c04b08a67278d1e9f04b9a5cdabaa32e1ead6f)

AI engineering on the product side of the API boundary.

**An accessible API does not remove the need to understand model behavior.** You need enough foundation-model knowledge to understand why an output might differ from what your application expects. You also need to recognize when to customize a model for a particular use case or dataset, including through fine-tuning, and how application functions can give it access to additional systems. Those are separate engineering decisions: understanding the model, adapting it, and connecting it to software.

For that foundation, Antje Barth recommends Generative AI with Large Language Models, a course developed with colleagues, Andrew Ng, and DeepLearning.AI. It introduces generative AI fundamentals with the goal of building real applications and is offered through DeepLearning.AI and Coursera.

### Use AI across the development lifecycle

[2:29](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=149s)

The second step is to use AI developer tools in everyday work. Natural language becomes another interface to development: a request can produce a rewritten README, while existing code can become an English explanation or function documentation. The useful direction runs both ways—from a description toward a software artifact, and from code toward understanding.

That expands the opportunity beyond typing code faster. Planning, design, testing, deployment, and maintenance surround implementation. Barth offers a rough workload framing: sometimes up to 70% goes to boilerplate, documentation, and maintenance, leaving perhaps 30% for creative development. This is an illustrative split, not a measured productivity result for Amazon Q; the point is that assistance can target the work around feature implementation too.

![Slide shows 70/30 above a sequence of Plan, Design, Implement, Test, Deploy, and Maintain connected by arrows.](https://ai.engineer/api/talk-essay-media/9fe347675f4b397dca74065b1c189f2201b1d7cb858294bcafb45b6f487309ec)

The software development lifecycle, from planning to maintenance.

Amazon Q Developer is introduced as an assistant for that broader lifecycle. Its agents can tackle feature development and code transformation, in addition to code completion. Moving an older Java codebase to a newer Java version is one proposed transformation use case; the demonstration that follows instead builds up from IDE assistance to a feature change spanning project files.

### Move from IDE guidance to a reviewed feature change

[5:02](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=302s)

Mike Chambers begins inside the IDE with an ordinary chat question about creating a serverless application. Q responds with a sequence starting at AWS SAM CLI installation and continuing through project creation. Once generated project code is available, he selects it, opens the context menu, and asks Q to explain it. The selected code becomes part of the explanation prompt. The same interaction can help with an unfamiliar legacy system, where the original author is no longer available to explain the implementation.

Next, Chambers supplies a comment describing an input-checking function, then narrows the requirement: trim any incoming string. Q generates the small function from that local description. This is the familiar completion workflow: the developer states a small intent close to the code, and the assistant supplies an implementation.

The demonstration then grows from a function into a feature. Using the recording’s `/dev` interface, Chambers requests a DynamoDB search by category and specifies how its output should be formatted. The workflow proceeds through distinct stages:

1. **Describe the feature.** Provide the search requirement and output details in chat.
2. **Inspect the plan.** Q identifies project changes, including work in `template.yaml` and a proposed `searchByCategory.mjs` file.
3. **Review the change set.** Q follows the plan to generate proposed code, exposing differences from the current project.
4. **Accept the changes.** The demonstrated `Insert code` button applies the generated code to the project if the developer approves it.

**A generated plan becomes useful when it leads to inspectable changes.** The review step separates a proposal from code accepted into the project; this is more than a longer autocomplete suggestion.

For further examples, Barth points to Amazon Q Developer Center, along with the conference’s Q sessions and AWS booth demonstrations.

### Prototype around a use case, then evaluate models

[8:26](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=506s)

The third step shifts from using an AI assistant to building an AI application. Start by defining the use case, then choose candidate models and decide how to adapt them. Prompt engineering, retrieval-augmented generation (RAG), and fine-tuning are options to consider against that use case, rather than mandatory stages every application must pass through.

Responsible AI policies, privacy, security, and guardrails belong throughout this workflow. After integration, agents and deployed models also need ongoing maintenance—the operational work often described as GenAI Ops or LLM Ops. Model selection sits within this larger lifecycle: evaluate candidates thoroughly because different application tasks may call for different models. **A common application platform does not imply a single best model for every use case.**

Amazon Bedrock is presented as the managed platform for this experimentation. It combines access to foundation models with tooling for fine-tuning, RAG workflows, and agents. Barth emphasizes a secure environment and control over application data. The talk’s model lineup includes providers AI21 Labs, Anthropic, Cohere, Meta, Mistral AI, and Stability AI, alongside Amazon’s **Titan** models.

The release context is June 2024: Barth highlights [**Claude 3.5 Sonnet**](https://aws.amazon.com/blogs/aws/anthropics-claude-3-5-sonnet-model-now-available-in-amazon-bedrock-the-most-intelligent-claude-model-yet/) as having arrived on Bedrock the previous week. That historical lineup sets up the next integration problem: how to experiment across providers without rewriting the invocation code for each one.

### Keep model invocation consistent with Converse

[11:29](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=689s)

The [Converse API](https://aws.amazon.com/about-aws/whats-new/2024/05/amazon-bedrock-new-converse-api/), newly introduced at the time of the recording, provides a common invocation structure. Instead of making the application translate parameter names and message formats for each model, Bedrock handles that translation. The interface accommodates system instructions and user/assistant messages and returns a consistent output structure.

The Python example follows a short sequence: initialize the SDK client, construct messages, and call `converse` with a model ID and inference parameters. The following uses that same structure, with the model ID supplied through the environment:

```python
import os
import boto3

client = boto3.client("bedrock-runtime")

messages = [
    {
        "role": "user",
        "content": [{"text": "Explain how an API helps developers use AI models."}],
    }
]

response = client.converse(
    modelId=os.environ["BEDROCK_MODEL_ID"],
    messages=messages,
    inferenceConfig={
        "maxTokens": 256,
        "temperature": 0.2,
    },
)

for block in response["output"]["message"]["content"]:
    if "text" in block:
        print(block["text"])
```

The request separates the conversation in `messages` from generation settings in `inferenceConfig`. In the recording, the selected model is from Anthropic; the common call structure is what lets the developer experiment with other supported models by changing the model selection.

![Python code beside model-provider logos, with a pink rectangle around the Converse call, model selection, messages, and inference configuration.](https://ai.engineer/api/talk-essay-media/0e3fed457a3be43f3c7f32071c2b2d724b6757be128e77ca8bfefd25013ebe82)

A Python Converse example with the model invocation highlighted.

### Declare the functions a model can request

[13:06](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=786s)

Converse also supports function calling for models that provide that capability. The setup described here is to define a list of tools representing application functions, then pass that list with the Converse call. **A common invocation interface does not make tool support universal across models.** The tool list describes the functions available for use; the next demonstration makes that connection concrete with code-backed actions in an agent.

For more detailed examples across languages, Barth points to the generative AI space on community.aws and names Dennis Traub as a tutorial author.

### Give an agent instructions and code-backed actions

[13:58](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=838s)

The fourth step is application integration, illustrated through a Minecraft agent. Chambers opens an agent configured in the AWS console, describing the agent workflow as fully serverless. In the agent builder, the selected model is **Claude 3 Haiku**, and the instructions tell the Minecraft bot how to play. Those instructions are operational prompts, not notes for the developer.

The agent also needs actions it can perform. Chambers has organized these into Minecraft actions and an experimental action group. Inside the actions group, tools such as jump and dig connect to code. Their descriptions explain their intended use, making the tool descriptions another part of prompt engineering. Required parameters give the agent information it must obtain before using an action.

Two more actions prepare the central demonstration:

| Action | Role in the workflow |
| --- | --- |
| Get a player’s location | Obtain the destination associated with a player |
| Move to a location | Move the bot toward that destination |

These are small, reusable capabilities. Together, they let the agent address a request whose wording does not correspond to a dedicated action.

### Compose actions to answer “Come to me”

[16:18](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=978s)

Inside Minecraft, Chambers first changes nighttime to daytime so the movement will be visible. Rocky, the Bedrock-powered bot, stands in the game world and can receive messages through chat. Chambers backs away to make the request more interesting. There is no dedicated tool for coming to the player.

He types “Come to me.” The described workflow connects the chat request to the available actions:

1. Identify which player sent the request.
2. Use that player’s name to obtain their location.
3. Use the destination to move Rocky from its current position toward the player.

Chambers describes the final step as mapping a path to him. Rocky reaches the player, and the game chat confirms arrival. The useful result is **composition of existing tools into a requested behavior**, without adding a special-purpose come-to-player action.

![Minecraft character Rocky stands near the player; chat says it has arrived at the player's location and asks what they would like to do together.](https://ai.engineer/api/talk-essay-media/eabba554f755f7ad1a253ddad9e20ac1038d8c20282d9f8e1d95bee8444e599e)

Rocky reaches the player and confirms arrival in chat.

Barth points viewers to further demonstrations at the AWS booth and in the agents track, and says the project code is available on GitHub for people who want to explore the integration themselves.

### Keep learning with other builders

[17:50](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1070s)

The fifth step is continued learning through community participation. As models, tools, and application patterns change, workshops and conversations with other builders become part of staying current. Barth closes by announcing plans for an AWS AI engineering hub in San Francisco, with workshops, events, and meetups.

The invitation includes shaping that program: suggest topics through a survey, volunteer to speak, or offer to host a meetup. At the time of the talk, an Anthropic happy hour was near or at capacity, and additional events were planned for the following weeks and months. The closing opportunity is to participate in the learning community as a contributor as well as an attendee.

## Resources

- [The Rise of the AI Engineer](https://www.latent.space/p/ai-engineer) — Swyx’s essay introducing the AI engineer role and application development around foundation models.
- [Amazon Bedrock’s Converse API launch](https://aws.amazon.com/about-aws/whats-new/2024/05/amazon-bedrock-new-converse-api/) — The May 2024 announcement explains unified model invocation, conversation history and supported function calling.
- [Claude 3.5 Sonnet’s original Amazon Bedrock launch](https://aws.amazon.com/blogs/aws/anthropics-claude-3-5-sonnet-model-now-available-in-amazon-bedrock-the-most-intelligent-claude-model-yet/) — AWS’s June 20, 2024 announcement documents the model release discussed in the talk.

## Slides

### Presenting sponsor: Microsoft

Microsoft is the presenting sponsor.

[0:05](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=5s) [Microsoft logo beneath the words Presenting Sponsor.](https://assets.ai.engineer/sites/aiecode2025/sha256/d91b57d525f2e7e039f7e37f623eb6dd9a0ccbd4bc2a38e3a622a0ca2a4252f0.webp)

PRESENTING SPONSOR

Microsoft

### Innovation and platinum sponsors

AWS is the innovation sponsor; MongoDB, Google Cloud, and Neo4j are platinum sponsors.

[0:10](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=10s) [AWS is the innovation sponsor; MongoDB, Google Cloud, and Neo4j are platinum sponsors.](https://assets.ai.engineer/sites/aiecode2025/sha256/b33c4dffe2a4220a31eba5617142267dd15549687435e96dd54768b5422002eb.webp)

INNOVATION SPONSOR
aws

PLATINUM SPONSORS
MongoDB®
Google Cloud
neo4j

### The AI engineer role

The diagram places AI engineers on the product side of the API, working on chains, agents, tooling and infrastructure. ML roles sit on the data and research side.

[0:34](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=34s) [A diagram places AI engineers between machine learning roles and full-stack engineers, across an API boundary.](https://assets.ai.engineer/sites/aiecode2025/sha256/d03d643610792434302b3173189488ec39fd42cade0025eb40bf8094b0996c9c.webp)

API

Data/Research constrained
Product/User constrained

ML Researcher / Research Scientist
- training
- evals

ML Engineer/ Data Scientist/ Research Engineer
- inference
- data

AI Engineer
- chains/agents
- tooling & infra

Fullstack Engineer
- product
- platform

Source: www.latent.space/p/ai-engineer

aws
© 2024, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Understand the basics of generative AI

The first step is to understand how foundation models work and why they can produce unexpected output in application code.

[1:09](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=69s) [Step 1: Understand the basics of generative AI.](https://assets.ai.engineer/sites/aiecode2025/sha256/dc194d4af24ccf9a1b732b1c9c19858edcd163325fffd055c9cf7beb4baa3b20.webp)

1
Understand the basics of (generative) AI

aws
© 2024, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Generative AI concepts

The speaker connects foundation model basics to unexpected outputs, fine-tuning for specific use cases and data sets, and functions that give applications access to additional systems.

[1:21](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=81s) [A collection of concepts including foundation models, tokens, prompting, RAG, vector databases, fine-tuning, agents, evaluation, and operations.](https://assets.ai.engineer/sites/aiecode2025/sha256/2571d125927e5b8a43f8953a10f98c57fa5c2efcd766eaf6a92301442210d55d.webp)

Foundation Models
Retrieval Augmented Generation (RAG)
Text generation
Tokens
Vector databases
Prompt Engineering
Agentic workflows
Model Selection
Fine-Tuning
Function Calling
Model Evaluation
FMOps / LLMOps / AIOps

aws
© 2024, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Increase your productivity with AI

The second step is to get hands-on with AI developer tools to increase productivity.

[2:30](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=150s) [Section 2 title: Increase your productivity with AI.](https://assets.ai.engineer/sites/aiecode2025/sha256/33e963140ee5d19941d7618e074c7fe156f76fadd5ee510d53495c631ef29d73.webp)

2
Increase your productivity with AI

aws
© 2024, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### English as a programming language

Karpathy’s post calls English the hottest new programming language. The speaker connects that idea to using natural language to interact with applications.

[2:40](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=160s) [Andrej Karpathy's post says the hottest new programming language is English.](https://assets.ai.engineer/sites/aiecode2025/sha256/eb23fbd69cacde63369d0388c54076ee388015b615a840acac08e8dbf5b14f98.webp)

Andrej Karpathy
@karpathy

The hottest new programming language is English

12:14 PM · Jan 24, 2023 · 4.8M Views

Source: x.com/karpathy

aws
© 2024, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Rewrite a README file

An AI rewrite expands a brief README into documentation of the voting app’s AWS infrastructure, including its DynamoDB table, IAM role, and provisioning steps.

[3:18](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=198s) [An arrow points from an original README excerpt to expanded documentation for a voting application's infrastructure.](https://assets.ai.engineer/sites/aiecode2025/sha256/b7541ffbd418108f00a8b3c8dd68d39ca96340a776e94221694bcdc67bf170ee.webp)

From “English-to-Code”

Rewrite a README file

Original README:
The `prepare.sh` script creates the DDB table and create an IA[illegible]
a policy to access it. You can associate this role to an Amazo[illegible]
service (the role is federated with Amazon App Runner).

The script assign a DDB table name and IAM role name in two va[illegible]
the beginning. You can change them if you wish.

Rewritten README:
# Provisioning Infrastructure for the Voting Application

The scripts in this preparation folder set up the required AWS infrastructure needed to run the voting application, including a DynamoDB database table and IAM role.

## prepare.sh

The prepare.sh bash script automates the provisioning steps. It takes the AWS region and table/role names as parameters.

The key steps it performs are:
1. Creates the "votingapp-restaurants" DynamoDB table with the "name" attribute as the hash key
2. Adds initial item entries for each restaurant option
3. Creates an IAM role called "votingapp-role" that App Runner can assume
4. Attaches a policy granting DynamoDB access to the specific table
5. Attaches AWS X-Ray write permissions to the role

See the script comments for more details on each DynamoDB and IAM API call.

## apprunner-trust-policy.json

This JSON file defines the trust policy that allows App Runner to assume the IAM role. It grants the "sts:AssumeRole" permission to the App Runner service principal.

Source: it20.info/2024/3/using-the-amazon-q-feature-development-capability-to-produce-documentation

aws
© 2024, Amazon Web Services, Inc. or its affiliates. All rights reserved.

Interface text: README.md ↔ README.md

### Code-to-English: Document functions in the code

The example asks AI to document two voting functions, adding comments that explain how they read and update restaurant votes in DynamoDB.

[3:23](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=203s) [A Python code excerpt introduces an example of documenting functions.](https://assets.ai.engineer/sites/aiecode2025/sha256/aeb89f5a3856003b9603adb9630a7932f531f4d6df2fc8cc9c4a005b4b7fd5a3.webp)

To
“Code-to-English”

Document functions
in the code

    def readvote(restaurant):
        response = ddbtable.get_item(Key={'name': restaurant})
-       # this is required to convert decimal to integer
        normilized_response = json.dumps(response)
        json_response = json.loads(normilized_response)
        votes = json_response["Item"]["restaurantcount"]
        return str(votes)

    def updatevote(restaurant, votes):

Source: it20.info/2024/3/using-the-amazon-q-feature-development-capability-to-produce-documentation

aws
© 2024, Amazon Web Services, Inc. or its affiliates. All rights reserved.

[3:29](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=209s) [Code example with generated comments explaining restaurant voting functions.](https://assets.ai.engineer/sites/aiecode2025/sha256/227f189ea23f192677c4e15c5f36eb9792b875239db52c0e08466b0fea76ec26.webp)

To
“Code-to-English”

Document functions
in the code

Original code:
    def readvote(restaurant):
        response = ddbtable.get_item(Key={'name': resta[illegible]
-       # this is required to convert decimal to intege[illegible]
        normilized_response = json.dumps(response)
        json_response = json.loads(normilized_response)
        votes = json_response["Item"]["restaurantcount"[illegible]
        return str(votes)

    def updatevote(restaurant, votes):

Documented code:
    def readvote(restaurant):
+       # this function receives the name of a restaurant as input
+       # it gets an item from DynamoDB where the key "name" matches the name of the restaurant
+       # it extracts the restaurantcount value into a variable called "votes"
+       # it returns the value of "votes" as string
        response = ddbtable.get_item(Key={'name': restaurant})
+       # this is required to convert decimal to integer
        normilized_response = json.dumps(response)
        json_response = json.loads(normilized_response)
        votes = json_response["Item"]["restaurantcount"]
        return str(votes)

    def updatevote(restaurant, votes):
+       # this function receives the name and votes of a restaurant
+       # it updates the item in DynamoDB matching the name
+       # it sets the restaurantcount attribute to the votes value
+       # it returns the updated votes value as a string
+
        ddbtable.update_item(
            Key={
                'name': restaurant

Source: it20.info/2024/3/using-the-amazon-q-feature-development-capability-to-produce-documentation

aws
© 2024, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Software development lifecycle: 70/30

Across the lifecycle, the speaker estimates that up to 70% of time can go to boilerplate, documentation and maintaining old code, leaving perhaps 30% for creative work.

[3:34](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=214s) [A 70/30 ratio above the stages from plan through maintain.](https://assets.ai.engineer/sites/aiecode2025/sha256/cb1cde5693d128ee62058469a9d9cd22cd80e892983ec7a70ab3dc8636b0fcc4.webp)

70/30

Software development lifecycle
PLAN → DESIGN → IMPLEMENT → TEST → DEPLOY → MAINTAIN

aws
© 2024, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Amazon Q Developer across the lifecycle

Amazon Q Developer spans the software lifecycle, using agents for feature development and code transformation as well as coding assistance. One example is migrating older Java code to a newer version.

[4:18](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=258s) [A 30/70 lifecycle diagram with coding assistant, feature development and code transformation capabilities.](https://assets.ai.engineer/sites/aiecode2025/sha256/537c958994e6cd94cf7e8c21e9a0ad652b301cce15f8e936b03ca7443a7e1cbb.webp)

30/70

Software development lifecycle
PLAN → DESIGN → IMPLEMENT → TEST → DEPLOY → MAINTAIN

AMAZON Q DEVELOPER
CODING ASSISTANT
FEATURE DEVELOPMENT
CODE TRANSFORMATION

aws
© 2024, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Opening Amazon Q chat

In VS Code, the demo points to New tab to start a conversation with Amazon Q Developer.

[5:00](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=300s) [Amazon Q chat panel with a New tab control in VS Code.](https://assets.ai.engineer/sites/aiecode2025/sha256/b3bd2cca9fbb255eef9e17d508a5d33a47f1b69851d4f579f4a0e4d6bf12a71e.webp)

Open a tab to chat with Q
New tab

Interface text:
Untitled (Workspace)
AMAZON Q: CHAT
PROBLEMS
OUTPUT
DEBUG CONSOLE
TERMINAL
PORTS
CODE REFERENCE LOG
maykyaw@f8ffc241074a ~/Q-demo %
zsh
zsh
AWS: AWS Builder ID
Amazon Q

### Asking about serverless applications

In the IDE, the demonstrator asks Amazon Q how to get started with a serverless application on AWS. The chat is generating a response.

[5:07](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=307s) [Amazon Q chat displays a question about getting started with a serverless application and a generating indicator.](https://assets.ai.engineer/sites/aiecode2025/sha256/6ff8a0b6d322a65e3fcad7b72e96c7f14505c613836d83622033671c84b42792.webp)

Hi, I'm Amazon Q. I can answer your software development questions. Ask me to explain, debug, or optimize your code.
You can enter / to see a list of quick actions.

What is the easiest way to create a serverless application on AWS? Where do I get started?

Generating your answer...

Ask a question or enter "/" for quick acti...
4000/4000
Use of Amazon Q is subject to the AWS Responsible AI Policy.

Interface text:
Untitled (Workspace)
AMAZON Q: CHAT
Chat
PROBLEMS  OUTPUT  DEBUG CONSOLE  TERMINAL  PORTS  CODE REFERENCE LOG
maykyaw@f8ffc241074a ~/Q-demo %
zsh
zsh
AWS: AWS Builder ID
Amazon Q

### Testing and deploying with AWS SAM

Amazon Q’s serverless setup instructions end with commands to test Lambda functions locally and deploy the application through AWS CloudFormation. The chat also suggests follow-up questions.

[5:15](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=315s) [Amazon Q response shows local testing and deployment steps, followed by suggested questions.](https://assets.ai.engineer/sites/aiecode2025/sha256/990d649ef5ce4cc5da74ebcdf809a09c95f387e9196c01fdc083806396ffc511.webp)

Modify the code in this project for your application's use case.

5. Test locally: Use sam local invoke to test your Lambda functions locally before deploying.
6. Deploy to AWS: Finally, run sam deploy --guided to package and deploy your serverless app to AWS CloudFormation. [3]

The AWS SAM CLI simplifies the process by providing an enviro

Suggested follow up questions:
What is AWS SAM CLI?
What is AWS CloudFormation?
What is AWS Lambda?

Interface text:
Untitled (Workspace)
AMAZON Q: CHAT
Chat
PROBLEMS
OUTPUT
DEBUG CONSOLE
TERMINAL
PORTS
CODE REFERENCE LOG
maykyaw@f8ffc241074a ~/Q-demo %
zsh
zsh
Ask a question or enter "/" for quick action
4000/4000
Use of Amazon Q is subject to the AWS Responsible AI Policy.
AWS: AWS Builder ID
Amazon Q

### Getting started with AWS SAM

Amazon Q answers a serverless application question with setup instructions, beginning with installing the AWS SAM CLI and configuring AWS credentials.

[5:30](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=330s) [Amazon Q response introduces AWS SAM and begins instructions for installing its CLI and configuring credentials.](https://assets.ai.engineer/sites/aiecode2025/sha256/aa95198be4b4910222837a6ffc9b2c7fb2762a55b77710582cf2b182ae048bae.webp)

Amazon Q: Creating a serverless application on AWS is straightforward with the AWS Serverless Application Model (AWS SAM). Here are the steps to get started: [1]

1. Install AWS SAM CLI: The AWS SAM CLI is a tool that helps you develop, test, and deploy serverless applications. Install it from
https://docs.aws.amazon.com/serverle[illegible]
application-
model/latest/developerguide/serverles[illegible]
sam-cli-install.html

2. Set up AWS credentials: Configure your AWS credentials by running aws configure and entering your access key and secret key. This [illegible]

Interface text:
Untitled (Workspace)
AMAZON Q: CHAT
Chat
PROBLEMS  OUTPUT  DEBUG CONSOLE  TERMINAL
maykyaw@f8ffc241074a ~/Q-demo %
zsh
zsh
Ask a question or enter "/" for quick action
4000/4000
Use of Amazon Q is subject to the AWS Responsible AI Policy.
AWS: AWS Builder ID
Amazon Q

### Inspecting generated handler code

The generated SAM example opens a GET-by-ID handler. It creates a DynamoDB document client, reads the table name from an environment variable, and takes the item ID from the request path.

[5:34](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=334s) [VS Code shows a serverless project and JavaScript handler code for retrieving an item.](https://assets.ai.engineer/sites/aiecode2025/sha256/362af64ee9a3c57cef3596c14f1eae796cc9979efb4227e07fa66836a666cc04.webp)

// Create clients and set shared const values outside of the handler.

// Create a DocumentClient that represents the query to add an item
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocumentClient, GetCommand } from '@aws-sdk/lib-dynamodb';
const client = new DynamoDBClient({});
const ddbDocClient = DynamoDBDocumentClient.from(client);

// Get the DynamoDB table name from environment variables
const tableName = process.env.SAMPLE_TABLE;

/**
 * A simple example includes a HTTP get method to get one item by id from a Dyr[illegible]
 */
export const getByIdHandler = async (event) => {
  if (event.httpMethod !== 'GET') {
    throw new Error(`getMethod only accept GET method, you tried: ${event.http[illegible]
  }
  // All log statements are written to CloudWatch
  console.info('received:', event);

  // Get id from pathParameters from APIGateway because of `/{id}` at template.[illegible]
  const id = event.pathParameters.id;

  // Get the item from the table
  // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentC[illegible]
  var params = {

Interface text:
Untitled (Workspace)
EXPLORER
OPEN EDITORS
get-all-items.mjs  sam-q-demo/src/handlers
get-by-id.mjs  sam-q-demo/src/handlers
UNTITLED (WORKSPACE)
Q-demo
  sam-q-demo
    __tests__
    events
    src/handlers
      get-all-items.mjs
      get-by-id.mjs
      put-item.mjs
    .gitignore
    buildspec.yml
    env.json
    package.json
    README.md
    samconfig.toml
    template.yaml
OUTLINE
TIMELINE
Q-demo > sam-q-demo > src > handlers > get-by-id.mjs > ...
AWS: AWS Builder ID
Amazon Q
Ln 1, Col 1
Spaces: 2
UTF-8
LF
JavaScript

### Generated input-checking function

Amazon Q generates a function from a code comment. It trims string inputs and returns other inputs unchanged.

[6:31](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=391s) [A JavaScript function trims string inputs and returns other inputs unchanged.](https://assets.ai.engineer/sites/aiecode2025/sha256/00a4c7d9c13bab1d778b63d8bf1832846da70cb1f850b146d83c5df2d8a407fc.webp)

const uploadFile = async (fileName) => {

    // Uploading files to the bucket
    await s3.upload(params, function(err, data) {
    if (err) {
        throw err;
    }
    console.log(`File uploaded successfully. ${data.Location}`);
    });
};

//Function to check if the input is null/undefined.  If the input is string, trims any leading or tr[illegible]
const checkInput = (input) => {
    if (typeof input === 'string') {
        return input.trim();
    } else {
        return input;
    }
}

Interface text:
Untitled (Workspace)
get-all-items.mjs
get-by-id.mjs
put-item.mjs
Q-demo > sam-q-demo > src > handlers > put-item.mjs > checkInput
AWS: AWS Builder ID
Amazon Q
Ln 78, Col 6
Spaces: 4
UTF-8
LF
JavaScript

### Opening Amazon Q developer chat

The presenter opens Amazon Q chat and uses /dev to prepare a request for a DynamoDB category-search function with specific output formatting.

[6:37](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=397s) [Amazon Q chat beside a JavaScript handler in the editor.](https://assets.ai.engineer/sites/aiecode2025/sha256/19a6ed3fde3ad43dcbed90bc9f65ae23b66b4ab77d078a69ea69eced1b1db9ab.webp)

15 export const getByIdHandler = async (event) => {
27     var params = {
28         TableName : tableName,
29         Key: { id: id },
30     };
32     try {
33         const data = await ddbDocClient.send(new GetCommand(params));
34         var item = data.Item;
35     } catch (err) {
36         console.log("Error", err);
37     }
39     const response = {
40         statusCode: 200,
41         body: JSON.stringify(item)
42     };
44     // All log statements are written to CloudWatch
45     console.info(`response from: ${event.path} statusCode: ${response.statusCode} body: ${response.body}`);
46     return response;
47 }

Interface text:
sam-q-demo
AMAZON Q: CHAT
Chat
get-by-id.mjs
src > handlers > get-by-id.mjs > getByIdHandler
/dev Describe your task or issue in as much detail as [illegible]
3996/4000
Use of Amazon Q is subject to the AWS Responsible AI Policy.
AWS: AWS Builder ID
Amazon Q
Ln 38, Col 2

## Full transcript

[0:00](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=0s) [upbeat music] Hi, everyone. I'm so excited to be part of this conference and share with you five practical steps from software developer to AI engineer.

[0:26](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=26s) And if anyone is wondering here, this avatar on the slide, this is what happens if you ask AI to make you look a little bit more agentic. [laughs]

[0:36](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=36s) All right, let's get started. So I'm pretty sure everyone is familiar with this image here and the post from swyx that defines the new role of the AI engineer.

[0:47](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=47s) And as you've experienced, uh, probably daily in your jobs, you don't need to be a full ML researcher anymore or data scientist. Things that took month or years before to get AI projects into production is now able to be in just a couple of API calls.

[1:06](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=66s) Super exciting. But still, if you're working with AI, it still makes sense to understand the basics of the technology,

[1:18](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=78s) and this involves a couple of things, right? So you have to understand at a basic level how foundation models work, why they're sometimes producing output that you don't expect in your application code, right?

[1:32](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=92s) You have to understand how you can customize the models, how you can, you know, for example, sometimes fine-tune models to adapt them to your specific use cases and data sets, how to include functions in your application code to give them access to additional systems.

[1:50](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=110s) The good news is, if you're just starting on this journey to becoming an AI engineer, there's plenty of resources now these days available to you to learn. And I wanted to call out one specific course here, which is called Generative AI with Large Language Models.

[2:07](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=127s) A few colleagues and mine, we actually collaborated with Andrew Ng and the team at DeepLearning.AI to put this course together and help you understand the fundamentals of generative AI to help you build real-world applications.

[2:22](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=142s) If you're curious, it's available on DeepLearning.AI and on Coursera.

[2:29](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=149s) Now, the second step in this journey is to start get hands-on with the AI developer tools to help you increase your productivity.

[2:42](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=162s) And I think we're all seeing this quote here, and we experienced it in our daily jobs, that how we do work, how we develop applications, has changed a lot.

[2:55](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=175s) These days, we can literally use natural language inputs to interact with applications, and really, English has become one of the most, um, popular and hottest programming languages, I think, um, we can see this happening.

[3:12](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=192s) For example, you can go these days from English to code by asking AI to, for example, rewrite a README file.

[3:24](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=204s) We can also do code to English, for example, asking AI to document functions in our code.

[3:35](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=215s) But this is not all. If we look at the software development life cycle, I think many of us can agree that the majority of time we usually spend not writing valuable code, but all the other things around it.

[3:48](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=228s) So sometimes up to seventy percent of unvaluable tasks, which is writing boilerplate code, writing documentation, trying to maintain old code bases, right? And sometimes we only have like a fraction of the time, maybe thirty percent, that we're spending on actually what, you know, creates joy and kind of the creative tasks in software development.

[4:12](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=252s) And this is what led us at AWS, this inspired us to create Amazon Q. Amazon Q is a generative AI-powered assistant specifically developed for software development,

[4:27](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=267s) and this is much more than just a coding assistant. Q Developer actually uses agents to perform much more complex tasks and help you automate those, for example, feature development and also code transformation.

[4:44](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=284s) Think about working with old Java-based code bases that you need to migrate maybe to a newer Java version.

[4:53](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=293s) And to show you how this works, I asked my colleague, Mike Chambers, to put together a quick demo. Let's have a look.

[5:02](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=302s) With Amazon Q installed inside of my IDE, I can go to New Tab, and I can start a conversation with Amazon Q Developer. And I can do the kinds of things that maybe you'd expect, such as, "How can I create a serverless application," and, "How do I get started?"

[5:19](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=319s) And the chat session brings back a list of instructions of what I should do, starting off by installing AWS SAM CLI, how to do that, where to get that from, and how to step through the creation of a project.

[5:34](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=334s) Now, if I've done that, then Serverless SAM, for example, might actually come back with some generated code, and here is that code. Maybe I don't quite know what this code does, so I can right-click on the code and send it to Amazon Q, asking Amazon Q to explain.

[5:52](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=352s) And the code then will go into a prompt along with explain and generate an answer. And this is great for code that's been generated for us. But also imagine code for legacy systems, something that was worked on years ago by somebody else, where you can get Amazon Q to help explain it.

[6:11](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=371s) We can also get Amazon Q to generate code. Now, this is, again, probably the kind of thing you'd expect. I can put in a comment line inside of my code.

[6:20](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=380s) In this case, I want to create an input checking function. I'm going to give it some more definition here that I actually want it to trim any string that's being sent into this function.

[6:31](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=391s) And yes, Amazon Q can generate this small function. Well, that's great, but what about if I've got more code that I need to have generated? Well, I can go to the chat and put in /dev, and I can put in a much more comprehensive description of something that I would like.

[6:49](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=409s) In this particular case, I'm gonna ask for it to write a function to search by category in DynamoDB with a bunch of details about the way that I want the output to be formatted.

[7:02](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=422s) So this is much more than just a single or a few lines of code. And in this particular case, what's gonna happen is it'll come back again with a step-by-step list of what's required.

[7:14](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=434s) So I need to add in template.yaml. It's recommending that I create searchByCategory.mjs and many more things. But this isn't just a big shopping list of things that I need to do.

[7:29](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=449s) This is actually a plan, and it's a plan that Amazon Q can actually follow for us. So it generates some code as a change set, something that we can look at the difference between our current code and what it suggests.

[7:44](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=464s) And if we like that, we can actually click on the Insert code button, and it will add all of that code into our project, way more than just a couple of lines.

[7:55](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=475s) So Amazon Q Developer is much more than just code completion.

[8:03](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=483s) All right. If you're curious to learn more about Amazon Q, Amazon Q Developer, we have a couple of more sessions throughout this day, so make sure you're checking, um, those expo sessions, and we also do have a session at our AWS booth here.

[8:18](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=498s) You can also visit our Amazon Q Developer Center for much more examples what you can do with it.

[8:26](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=506s) All right, let's come to step three, and this is where the fun starts. Start prototyping and building with AI.

[8:35](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=515s) And the fun includes a couple of steps, right? Everyone developing with AI knows this. It starts all with defining a use case, and then really you're on this road trying to choose from different models.

[8:47](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=527s) You're trying to, you know, customize them to your use case, decide whether it's prompt engineering, whether you do s- RAG, whether you need to do a little bit of fine-tuning there with your data.

[8:58](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=538s) And of course, across the whole development workflow, you have to incorporate responsible AI policies, making sure data is private and secure, and also implementing guardrails into your application. And then when you're integrated, another fun part, obviously working with the agents, what we're hearing a lot here throughout this conference, and the fun topic of, you know, how to

[9:21](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=561s) keep them up to date, GenAI Ops, I think there's a lot of terms for that, MFM Ops, LLM Ops. So really kind of, um, a lot of things to consider here.

[9:31](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=571s) I wanna dive in briefly into the topic of models to choose, and this is really an important topic. When you're evaluating models, you have to really evaluate them thoroughly because most likely there's not just gonna be one size fits all for you.

[9:49](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=589s) In fact, if you look at all your use cases you want to implement, there's likely no one model to rule them all.

[10:00](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=600s) And this is why we developed Amazon Bedrock. Bedrock is a fully managed service that gives you access to a wide range of leading foundation models that you can start experimenting with, implementing into your applications.

[10:17](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=617s) It also integrates the tooling you need to customize your model, whether it's fine-tuning, also to include RAG workflows, to build agents, and of course, everything in a secure environment where you are in full control of your data.

[10:36](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=636s) And speaking of choice, just to give you a quick overview, as of today, this is the selection of models you can choose from. We're working with leading companies such as AI21 Labs, Anthropic, Cohere, Meta, Mistral AI, Stability AI, and we also offer our own Amazon Titan models for you to choose from.

[10:59](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=659s) And I'm super excited just to call this out. Last week, together with Anthropic's launch, we integrated Claude 3.5 Sonnet on Amazon Bedrock as well. So you can also, since last week, use this model.

[11:13](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=673s) Super exciting. Now, with choice also comes responsibility, right? And we continuously innovate and trying to make it easier for you to build applications across the different model types.

[11:29](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=689s) And just a few weeks ago, we introduced a new unified Converse API in Amazon Bedrock. What does this do? The unified Converse API helps you with a new unified method structured invocation, meaning you can use the same parameters and bodies regardless of which mo- model you choose.

[11:52](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=712s) And we are, on the platform side, we're handling this translation if parameters are called different for the different models, handling the system, user, assistant prompts for you, and also giving you a consistent output format.

[12:05](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=725s) And as well having native function calling support in here. But let me show you how this looks in code. So here's the Python example that shows how you can use the new API This is Python, so we're starting by just integrating the Python SDK client here.

[12:22](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=742s) And then you can define this list of messages. And here's, for example, where you put in your user message prompts. You can put in system prompts as well. And then this message list, you can just pass in this single API call using the Converse API here.

[12:40](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=760s) In the model ID, you can choose which model you wanna test. Here I'm using an Anthropic model. And then pass the messages and also the inference parameters. And again, in this API, all those parameters are standardized, and we're gonna make the work behind, um, the covers to convert this to the specific format that the model is expecting.

[13:01](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=781s) So you have an easy way to work across different models.

[13:06](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=786s) Similarly here for n- function calling, we do have the support built in that with the models that support it. So how we implement this is by defining a tool list.

[13:17](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=797s) So tool here equivalent to, to the functions you wanna give access to. And then when you're doing the Converse API call, you can pass this list of tools.

[13:30](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=810s) All right. If you wanna find out more about Converse API, here's the link to our generative AI space on community.aws, which has a lot more co- tutorials, code examples, not just for Python, but across different languages as well.

[13:45](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=825s) So check it out. The author here, Dennis Traub, is also somewhere here in the audience here this week, so if you wanna connect with him, talk about different code examples and how to use the API, um, feel free to reach out.

[13:58](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=838s) All right. Now, let's integrate AI into our applications. And this can be a whole session in its own, but I wanna focus on one of the hottest topics right now that we're discussing during the conference, which is of course agents.

[14:13](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=853s) And I have one more demo here, and I asked my colleague Mike last time to put together an exciting demo to show you what you can do with agents.

[14:24](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=864s) Mike. And we need sound.

[14:28](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=868s) To be able to create agentic workflows right inside of the AWS console and inside of the service. It works fully serverless, and I've used it to create an agent that plays Minecraft.

[14:40](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=880s) Let me show you [laughs] how I did it. If we jump into the AWS console, dro- go down the menu on the left-hand side to agents, um, you can see the agents screen here, and I can open up my agent, my Minecraft agent.

[14:52](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=892s) Now, if I just go into agent builder, uh, and just expand the screen out a little bit, you get to see some of the parameters that I used to create this agent.

[15:01](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=901s) So you can see the large language model I used, in this case, Claude 3 Haiku. And you can also see this, the instructions for the agent. Now, this is not some notes for myself.

[15:10](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=910s) This is actually prompt engineering that we're doing to explain how we want the agent, in this case, the Minecraft bot, to play the game. And then we also have to add some tools in, right?

[15:21](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=921s) Some Minecraft tools. So we do that through actions and inside of action groups. So I've got a couple of different action groups. We've got Minecraft actions and Minecraft experimental.

[15:30](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=930s) Let's have a look at actions. And inside of here, we can see some really simple things, some actions that the bot will be able to do. And these are all linked up to code.

[15:40](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=940s) So we've got the action to jump. We've got the action to dig. And you can see the description here for action to dig. It's got some instructions. Again, this is prompt engineering.

[15:50](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=950s) And then we've got some parameters that we can select, c- collect. In fact, we require these parameters. So the bot needs to get these for us. Um, if I scroll down a little further, there's a couple of really simple actions in here.

[16:02](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=962s) Action to get a player location and action to move to a location. And I'm gonna show you those in action because the bot can actually problem solve and reason its way to be able to use these tools to solve simple problems.

[16:18](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=978s) Let's jump into the game. Um, and so it is nighttime. So let's set it to be the daytime, um, so that we can see what's going on. So set time to day.

[16:28](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=988s) Okay. And there in the middle of the screen, you can see Rocky. Rocky is the Bedrock agent running inside of the game. And we can talk to it, and we can have a chat session, but what about if we want it to come to us?

[16:40](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1000s) Now, there is no tool to come to us. So if I just... I'm just gonna back up a little bit further, make it a little bit more of a challenge.

[16:48](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1008s) And I'm gonna say, "Come to me" in chat. And what's gonna happen now is that the agent's going to reason through a whole set of actions. It's going to look to see who requested that.

[16:58](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1018s) It's then gonna take that name, and that's my name, and it's going to find the location of that player. And then it's going to map a path from where it currently was to me.

[17:08](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1028s) All of those things happened all in that blink of an eye, and there's agentic workflows making all of that happen. This is super exciting. I'm discovering new things that this bot can do every day.

[17:19](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1039s) Um, but with that, it's back to you. [laughs]

[17:23](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1043s) All right. Thank you, Mike. If you're curious to know how we did this, check out our booth session. We, we're running the demo there as well. And we have another session in the agents track later today, so make sure you're popping in there if you wanna know more.

[17:38](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1058s) And of course, you can find the project code for this on GitHub. So if you wanna play, play it on your own in how you can integrate agents into a fun thing, check out this project.

[17:50](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1070s) All right. We're f- almost there. So the last step I really wanna call out is stay up-to-date. There's so much happening in this space, as you all know. And a really good way to do that is to engage with the community.

[18:04](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1084s) Speaking of community, I have one last announcement to make, and I'm super excited to announce that we're transforming our AWS [REDACTED:location] here in San Francisco into the AI engineering hub for the community.

[18:20](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1100s) So we're super excited to host workshops, events, and meetups there.

[18:26](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1106s) If you wanna suggest a couple of topics you're most interested in to make those events most valuable to you, fill out this quick survey here. Also, if you're interested in speaking or hosting a meetup yourself, you can let us know.

[18:39](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1119s) And also, we do have another event tonight, which I think we're reaching capacity or just half reach capacity, but we do have a happy hour with Anthropic tonight at the [REDACTED:location].

[18:52](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1132s) In case you didn't make it anymore and we're at capacity, um, don't worry. We're working on putting together much more events like this in the upcoming weeks and month.

[19:02](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1142s) So keep an eye out for those. And with that, I'm coming to the end of our presentation. This wraps it up, the five practical steps to become an AI engineer.

[19:13](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1153s) And let's innovate together. And I'm looking forward, and I'm excited to see what you build with AI. Thanks so much. Make sure you're checking out the rest of the sessions here, and also pop by our booth outside.

[19:27](https://www.youtube.com/watch?v=90Ir4TMMbS0&t=1167s) Thanks so much. [upbeat music]
