Kiro Quickstarts for Amazon Quick: AI-Assisted Development That Actually Works
Six open-source projects with working scripts, tested patterns, and steering files that give Kiro the context it needs to help you automate Amazon Quick APIs — from Q-Topics to cross-account migrations.
AI coding assistants are everywhere, but they struggle with AWS APIs — especially newer or less-documented ones like the QuickSight API . They confidently generate code with deprecated parameters, invent methods that don't exist, or miss critical requirements buried in the documentation. This isn't the AI's fault. It's a context problem. I helped build Kiro Quickstarts to solve it: pre-built projects with working scripts, tested patterns, and steering files that give Kiro the context it needs to help you effectively with Amazon Quick .
The Context Problem
You've probably experienced this. You ask an AI assistant to help with an AWS API, and it generates code that doesn't work. Maybe it uses deprecated parameters, invents methods that don't exist, or misses critical requirements buried deep in the documentation.
AI models are trained on documentation and code samples, but documentation alone isn't enough. To work effectively with an API, you need exposure to real implementations: working examples, edge cases, error handling patterns, and the kind of knowledge that only comes from hands-on experimentation. Without that foundation, even the best AI assistant gives you generic, often incorrect guidance.
The QuickSight API is a particularly good example. It has hundreds of operations across asset management, identity, Q-Topics, and migration workflows. Many of these operations have undocumented quirks — async job patterns that aren't obvious from the method signatures, identity store restrictions that depend on your namespace configuration, folder path behaviors that trip up every developer the first time. An AI assistant without context will miss all of this.
Context-First Development
Kiro Quickstarts flip the script. Instead of starting from scratch and hoping the AI figures it out, you start with a project that already has:
- Working scripts you can run immediately
- Tested patterns that handle real-world edge cases
- Steering files that encode domain knowledge
- Sample data for reproducible demonstrations
When you open a Kiro Quickstart in Kiro, the AI arrives pre-loaded with the context it needs. It knows which APIs to use, what parameters matter, and how to handle common problems — because we've already done that work and encoded it into the project.
What Makes Steering Files Different
Steering files are markdown documents in the
.kiro/steering/ directory that tell Kiro what it needs to know about your project. They're not just documentation — they're structured guidance developed and validated by AWS Solution Architects through hands-on testing with real Amazon Quick deployments.Here's what makes them powerful.
Trigger Phrases
Each steering file defines specific phrases that trigger context-aware responses:
| You Say | Kiro Does |
|---|---|
| "Help me configure my AWS credentials" | Runs the interactive setup_aws_profile.py script |
| "Help me create a Q-Topic" | Checks your datasets first, then guides topic creation |
| "My import failed" | Analyzes the error and suggests specific fixes |
| "What can I migrate?" | Lists all exportable assets in your account |
Without these trigger phrases, Kiro gives generic advice. With them, Kiro knows exactly which script to run and what context to gather first.
Hard-Won Gotchas
The steering files encode knowledge about API quirks that would otherwise cost you hours of debugging:
- Q-Topic Testing Limitation: There's no boto3 method to programmatically test Q-Topic queries. The
predict_qa_results()API exists but requires IAM Identity Center — it fails with standard IAM credentials. The steering file explains this upfront so you don't waste time trying to make it work. - Identity Store Restrictions: If your Amazon Quick namespace uses IAM Identity Center, you can list users but not create them via the QuickSight API. The steering file tells Kiro to check the identity store type before suggesting user creation commands.
- FolderPath Behavior: The
FolderPathfield contains ancestor ARNs but NOT the current folder's ARN. This trips up many developers — the steering file ensures Kiro explains this correctly every time. - VPC Connection Migration: VPC connections can't be automatically migrated between accounts. The steering file guides Kiro to ask about VPC dependencies before starting a migration.
Complete Workflows
Steering files define end-to-end workflows, not just individual commands. The asset bundle migration steering file, for example, includes:
- Session Start Protocol: Check if AWS credentials exist before doing anything else
- New User Path: If no credentials, run the setup script first
- Existing User Path: Ask which profile to use, then verify it works
- Migration Workflow: Analyze dependencies → collect credentials → generate config → execute
When you say "Help me migrate a dashboard," Kiro doesn't just give you a command — it walks you through the entire process, asking the right questions at each step.
Error Handling Patterns
The steering files include common errors and their solutions:
| Error | What It Means | Steering File Solution |
|---|---|---|
| "Enterprise Edition required" | Q-Topics/Asset Bundles need Enterprise | Explains the limitation, suggests upgrade path |
| "Operation is disabled for identities managed by IAM Identity Center" | Can't create users in IDC namespaces | Redirects to IAM Identity Center console |
| "VPC connection not found" | Target account missing VPC setup | Explains VPC migration options |
| "Access Denied" on AssumeRole | External ID mismatch or trust policy issue | Walks through trust policy validation |
Without these patterns, you'd spend hours searching documentation and forums. With them, Kiro diagnoses the problem immediately.
The Quickstarts Collection
We published six Quickstarts covering the most common Amazon Quick automation scenarios:
| Quickstart | What It Does |
|---|---|
| Q-Topic Enhancement | Create and optimize Q-Topics for natural language queries |
| Asset Bundle Migration | Export and import assets between AWS accounts |
| Action Connections | Build MCP servers for AI-powered Action Connectors |
| User & Group Management | Manage users, groups, and namespaces via API |
| Folder Operations | Organize assets with folders and scaled folders |
| Cross-Account Access | Implement secure cross-account IAM patterns |
Each repository is self-contained and can be used independently, but they're designed to work together for complex workflows like cross-account migrations with proper user provisioning.
Before and After
Let's say you want to create a Q-Topic via the API. Here's what typically happens without a Quickstart:
1
2
3
4
5
6
You: "Help me create a Q-Topic in QuickSight"
AI: "Here's how to create a Q-Topic..."
[]
[]
[]You spend hours debugging, reading documentation, and iterating.
With a Kiro Quickstart:
1
2
3
4
5
6
7
8
You: "Help me create a Q-Topic for my sales data"
Kiro: "I see you have the qtopic-enhancement project open.
Let me check your available datasets first..."
[Runs list_datasets.py]
[Identifies your dataset]
[Generates correct create_topic.py invocation]
[Explains the field synonym options]The difference isn't magic — it's context. The steering files tell Kiro what scripts exist, what patterns to follow, and what pitfalls to avoid.
Getting Started
Every Quickstart follows the same pattern:
1
2
3
4
5
6
7
8
9
10
11
12
13
# 1. Clone the repository
git clone https://github.com/aws-samples/sample-quicksuite-kiro-quickstart-<name>.git
cd sample-quicksuite-kiro-quickstart-<name>
# 2. Install dependencies
pip install -r requirements.txt
# 3. Verify your AWS setup
python3 test_setup.py
# 4. Open in Kiro and ask for help
# "Help me get started"
# "What can I do with this project?"The
test_setup.py script validates your AWS credentials and permissions before you start, so you know immediately if something's misconfigured.Setting Up AWS Credentials
All Quickstarts use boto3 to interact with AWS APIs. Before running any scripts, you need to configure your AWS credentials.
The Easy Way: Ask Kiro
The Quickstarts include steering files that teach Kiro how to help you set up AWS credentials. Open the project in Kiro and say:
"Help me configure my AWS credentials"
Kiro will run an interactive setup script that asks for your AWS Access Key ID and Secret Access Key, verifies the credentials work, tests QuickSight access, and saves the profile to
~/.aws/credentials. This is the recommended approach because Kiro guides you through the entire process and validates each step.Manual Setup
If you prefer to configure credentials manually:
AWS CLI Configure:
1
aws configure --profile quicksight-devYou'll be prompted for your AWS Access Key ID, Secret Access Key, default region (use
us-east-1 for QuickSight), and output format (json).Edit Credentials File Directly:
Create or edit
~/.aws/credentials:1
2
3
4
[]
aws_access_key_id = AKIA...
aws_secret_access_key = ...
region = us-east-1Then set permissions:
1
chmod 600 ~/.aws/credentialsUsing Named Profiles
For working with multiple AWS accounts, use named profiles :
1
2
3
# Set the profile before running scripts
export AWS_PROFILE=quicksight-dev
python3 test_setup.pyOr reference it in Python code:
1
2
3
4
import boto3
session = boto3.Session(profile_name='quicksight-dev')
client = session.client('quicksight', region_name='us-east-1')Required Permissions
Your IAM user or role needs permissions for the QuickSight APIs. At minimum:
quicksight:List*— List resources (datasets, topics, users, etc.)quicksight:Describe*— Get resource detailsquicksight:Create*— Create new resources (for write operations)quicksight:Update*— Modify existing resourcesquicksight:Delete*— Remove resources
For a least-privilege approach, see the QuickSight IAM actions reference .
Verifying Your Setup
Every Quickstart includes a
test_setup.py script that validates your credentials:1
python3 test_setup.pyThis checks that AWS credentials are configured, you can connect to QuickSight, and your account has the required permissions. If the test fails, it tells you exactly what's missing — or just ask Kiro: "Why did my setup test fail?"
A Note on Credential Security
The access key approach shown above works for getting started quickly, but for production workflows AWS recommends temporary credentials over long-term access keys. Consider IAM Identity Center (SSO) for automatic credential rotation via
aws configure sso, temporary security credentials from sts:AssumeRole for programmatic access, or IAM Roles Anywhere for workloads outside AWS. If you do use long-term access keys, rotate them regularly and follow the IAM security best practices .What About Kiro?
Kiro is AWS's agentic AI-powered IDE for spec-driven development. Unlike traditional code assistants that only autocomplete, Kiro converts natural language into structured specifications, coordinates autonomous agents that implement changes across multiple files, uses steering files to encode team conventions and guide AI behavior, and keeps documentation in sync with your evolving codebase.
The steering files are the key. They're markdown documents that tell Kiro what it needs to know about your project — API patterns, naming conventions, common pitfalls, and domain-specific knowledge. When Kiro reads these files, it gains context that transforms generic AI assistance into expert-level guidance.
When you open a Kiro Quickstart, Kiro arrives pre-trained. It already knows the APIs, the gotchas, and the best practices — because AWS Solution Architects have encoded that knowledge into the steering files through hands-on testing, not just documentation review.
What's Next
Each Quickstart targets a specific Amazon Quick capability with dedicated documentation that dives deeper into the concepts:
- Q-Topic Enhancement — Why AI needs metadata to understand your data
- Asset Bundle Migration — Moving dashboards between accounts safely
- Action Connections — Building MCP servers for generative BI
- User & Group Management — Identity stores and namespace isolation
- Folder Operations — Organizing assets at scale
- Cross-Account Access — The confused deputy problem and how to solve it
Start with the capability you need most, or explore the main repository for an overview of all available Quickstarts.
Resources
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article