The Kiro platform is the recommended AI-assisted tool at St. Thomas because it can natively incorporate institutional guardrails, workflows, skills, and a growing set of features. Supported by AWS, it fits naturally in our environment and promotes the Spec-Driven workflow, which is essential for production workloads.
Kiro offers various applications for working with it, depending on your role and needs:
Kiro IDE is an AI-powered Integrated Development Environment (IDE) for developers and cloud operations to manage documentation, tests, projects, and code (including Infrastructure as Code). This powerful tool enables small teams and individuals to achieve outcomes typically associated with larger organizations while maintaining architectural rigor, test coverage, and long-term maintainability. To be effective, Kiro requires deliberate guidance, thoughtful review, and a mindset shift from ad-hoc coding to structured, specification-led development.
Kiro CLI is an AI-powered Command Line Interface (CLI) that enables cloud operations via the AWS CLI, including running reports and analyses against resources, checking status, and more. This powerful tool lets users run queries about the current state of operations without executing individual AWS CLI commands. While you can use the Kiro CLI to update resources directly, St. Thomas follows Infrastructure as Code best practices, so apply changes to cloud infrastructure through Terraform and CloudFormation templates.
Agentic-AI is a powerful tool operating with the same permissions as you and can perform destructive actions! Please only allow read-only AWS CLI commands for queries, analysis, and reports.
Table of Contents
Introduction
What Is the Kiro IDE?
Kiro is an AI-powered Engineering Environment built on the open-source VS Code platform that supports AI-assisted, spec-driven system development. It enables engineers to design, implement, test, and document complete systems, including application logic, cloud infrastructure, pipelines, and operational workflows within a single, integrated workflow.
Kiro supports the full system lifecycle from planning, design, and implementation, making it suitable for both application-centric and infrastructure-centric projects.
Rather than focusing solely on code generation, Kiro helps developers and cloud engineers create and maintain requirements, designs, tasks, tests, and documentation as first-class artifacts tightly coupled to the codebase. This approach mirrors how large, well-staffed engineering teams operate while enabling a single developer or small team to achieve similar outcomes with AI assistance.
Why We Use Kiro
Kiro is part of the AWS ecosystem, enabling the creation of production-ready systems that are well-architected, fully tested, documented, and aligned with platform standards. This includes not only application code, but also Infrastructure as Code, deployment pipelines, security controls, and operational automation that must evolve together over time.
By emphasizing specifications before and during implementation, Kiro:
- Encourages planning before coding
- Keeps tests and documentation aligned with behavior
- Reduces technical drift as features evolve
- Makes complex systems easier to reason about and extend
Projects that once required a team of developers and weeks or months of coordination can often be delivered by a single developer working with Kiro, provided the problem space is well understood and guided by clear requirements.
Because Kiro is document-based, specs, requirements, design, and tasks can be saved to a repository and shared and reviewed by other team members.
This approach also removes much of the friction that typically causes testing and documentation to be postponed, rushed, or abandoned. The final 10%, which often accounts for 90% of the work, is performed alongside development.
When used within established Golden Paths and platform standards, Kiro acts as an accelerator. Steering documents and reference architectures guide AI behavior so that generated systems conform to university-approved security, networking, deployment, and operations patterns. All important factors to ensure solutions are maintainable, scalable, and sustainable.
Who Should Use Kiro
Kiro is designed for engineers and practitioners responsible for building, operating, and evolving production systems, not just writing application code. It is particularly effective for roles that must balance speed, correctness, and long-term maintainability.
Cloud and Platform Engineering: Use Kiro to design, provision, and evolve cloud infrastructure, pipelines, and platform services as cohesive, well-documented systems aligned with Golden Paths and platform standards.
Security Engineering and Governance: Use Kiro to define, enforce, and validate security requirements, controls, and compliance expectations as specifications that remain tightly coupled to implementation and testing.
Cloud Architecture: Use Kiro to translate architectural intent into enforceable designs, ensuring systems remain aligned with reference architectures, operational constraints, and long-term scalability goals.
DevOps and Reliability Engineering: Use Kiro to specify and validate deployment workflows, operational behavior, and reliability expectations so systems behave predictably across environments and over time.
Application Development: Use Kiro to implement features within clearly defined architectural, security, and operational constraints while keeping tests and documentation continuously aligned with system behavior.
How Kiro IDE Changes the Development Model
Because architecture, code, tests, and documentation are tightly bound to specifications, changes to projects developed with Kiro should continue to be made with AI assistance, even for small updates. This ensures the application remains:
- Consistent with its original intent
- Fully tested after every change
- Ready for future AI-assisted enhancements
This is not a limitation but a deliberate design choice.
As a result, repositories developed with Kiro more closely resemble team-engineered systems rather than handcrafted, single-developer projects.
Engineers remain fully accountable for architecture, security, cost, reliability, and correctness, regardless of whether changes are performed by humans or AI. AI accelerates execution, but does not replace engineering judgment, review, or responsibility.
How Kiro CLI Changes the Operations Model
With the Kiro CLI you don't need to memorize OS or AWS CLI commands to understand how your environment is operating. You can tell Kiro what report you need or what you want to analyze. "What Lambda functions are running Python 3.9?" or "What CloudFormation stacks have an ITS security classification of Red?" or "Parse the log files for Lambda Function XYZ and find how many errors were due to missing IAM permissions."
Important: Because Kiro CLI operates with the same permissions as you, please do not perform tasks that could modify, add, or delete resources. Kiro CLI is a powerful tool and should be used to review, report, and analyze. Changes to cloud infrastructure should be implemented via Infrastructure as Code with Terraform or CloudFormation.
When to Use Kiro (and When Not To)
Kiro is best suited for:
- Significant rewrites or redesigns
- Systems where long-term maintainability matters
- Projects with clear requirements or the ability to define them
Kiro may be less effective when:
- Proprietary vendor behavior is undocumented
- SDKs have subtle, undocumented constraints
- The problem space is poorly understood and cannot yet be articulated
These challenges can often be mitigated through well-written steering documents, which guide Kiro toward correct patterns, conventions, and architectural decisions.
Existing Codebases (Make it Kiro-Ready)
For small, tactical changes to existing codebases not built with a spec-driven approach, have Kiro review the project first and generate relevant documentation to understand the code section to update and any dependencies it may affect.
However, if you are doing major maintenance on a project that isn't yet spec-driven, it may be time to make it fully "Kiro-Ready."
Before implementing a new feature in an existing codebase with Kiro, adopt a spec-driven approach to bring all documentation and tests up to date.
- Copy in any steering documents or hooks that would be useful for the project.
- Prompt Kiro to review and update documentation and tests (update prompt to meet your needs as necessary):
- I need to ensure the documentation is up to date. Some notes may be outdated but still important to the architectural decisions made. Move anything out of date to an archives directory in the repository. First, we need to evaluate the documentation, all the md files in the repository, and ensure they are up to date with what the application actually does. If you find inconsistencies, add them to a report. Ask questions in the report, and I will respond. Such as "Document X states the function does Y, but later it states Z. The code looks like it does W. What path should I take?" We will use the report to create the specs before initiating a workflow. It is important that all documentation properly reflects the current state of the application and that the application is documented so that we can add features using AI
- Once Kiro has completed that process, you should be ready to add new features using the spec-driven approach.
A Note on Mindset
Using Kiro effectively requires a shift in mindset:
- Slow down. Use a disciplined approach.
- Review what the AI produces.
- Treat specifications as seriously as code.
- Guide, review, and correct decisions as you would with a human teammate.
Kiro moves quickly, but good engineering still depends on thoughtful direction and informed judgment.
Understand that the repository is no longer a handcrafted, single-person effort. AI-Assisted Engineered repos and applications reach the level of team-developed applications you would see at larger organizations. Every feature and fix must follow a spec-driven approach to ensure the application is implemented correctly and properly tested before being pushed to production.
This aligns with what is taught in undergraduate and graduate computer science programs and with what is practiced in industry.
Getting Started with Kiro
Before Diving In, you should spend some time working with Kiro on a small development project. It is NOT advisable to jump right into a production project.
Start small. Iterate. Learn.
Familiarize yourself with the following through documentation, videos, and a hands-on approach.
These topics link to documentation on the Kiro website:
A strong workflow that covers these concepts will be key to getting the most out of AI-assisted development.
After reading through the information below, be sure to review content in the Resources section.
Account Requirements
Follow all St. Thomas guidelines for working with AI when experimenting and learning, even if you are not using an enterprise account. Do not provide secret, confidential, or proprietary information.
If you are in a regular developer, operations, system, or cloud engineering role at the university, use an Enterprise Account. Check with the Cloud Team for pricing and recommendations. Depending on your usage plan, you may be able to receive a month or two of access when needed. This applies to student employees as well.
Students using Kiro for personal or academic work receive 1,000 free credits a month for one year through the Kiro for Students program provided by AWS.
For staff and student employee sign-in instructions using an enterprise account, see: Kiro IDE and CLI: Sign In using an Enterprise Account.
Installing Kiro
- Download and install from the Kiro.dev website.
- Kiro CLI in Virtual Environments: If you are installing the Kiro CLI for use in a virtual environment, install it within the environment rather than directly on your machine.
- For Linux (particularly RedHat): If you're mounting an NFS volume as your home directory, see the Issue Installation on Red Hat does not work #2636 on GitHub
- Possible solution: symlink the following to another, non-NFS directory:
~/.local/share/kiro-cli~/.kiro
- Alternate solution: export the variable
XDG_DATA_HOME:
export XDG_DATA_HOME=/<not NFS path>
- Sign In with an Enterprise Account (or evaluate using your personal AWS Builder ID)
- We recommend NOT IMPORTING your VS Code extensions to the Kiro IDE!
You will not need all the extensions you typically use, so start clean and don’t import extensions from VS Code when asked. Kiro will manage many, if not all, aspects of the development process, so you won't need common formatters, linters, and the like. You can always switch to VS Code if you find certain extensions useful during review.
Note: Extensions installed in Kiro must be available through the Open VSX Registry, so extensions only available in the MS VS Code marketplace cannot be installed. This includes the extension we typically recommend for connecting to WSL and UTM.
To use with a St. Thomas Virtual Development Environment, such as WSL or UTM, install an SSH/Remote extension in Kiro:
- WSL: Open Remote – WSL (jeanp413)
- After installing, within Kiro use Ctrl + Shift + P then enter into the prompt:
Preferences: Configure Runtime Arguments
- This will open argv.json. Add a new property with value:
"enable-proposed-api": ["jeanp413.open-remote-wsl",]
- Save and restart Kiro
- UTM: Open Remote – SSH (jeanp413)
Follow the standard setup process for those extensions. WSL makes the connection automatically, but UTM may require a configuration step. You will not need to re-establish SSH keys if you already have VS Code connected to UTM. We recommend setting up VS Code first.
Spec-Driven Development vs. Vibe Coding
Vibe Coding
Please do not vibe code applications meant for production or widespread use. Reserve vibe coding for small changes, experiments, personal projects, and automation of small tasks.
When working within a production project, you should vibe code outside (in a sandbox) and bring what you learned in as a specification to the production project.
Specifications and Requirements are just as important as Infrastructure as Code.
Spec Driven Development
Kiro excels at spec-driven development.
This isn’t as hard to get started as it seems; however, it helps to start with steering documents so specific pathways to production can be followed, ensuring the application can be integrated into our cloud environment.
Usually, when paired with reusable steering documents, even a complex application can start with a prompt a paragraph or two long. Kiro can then do the hard work of writing all the implementation documentation in line with best practices, steering documents, and your prompt.
Project Organization
The article AWS Kiro: The real Development Environment provides a good overview of starting a project, adding to a project, creating steering documents, and hooks. (The article is linked again in the Resources section of this KB.)
Kiro directory (.kiro/)
You will find feature and fix specs covering all previous work, as well as application-specific steering documents in the .kiro directory. These documents are essential to Kiro’s (and others’) understanding of the project.
Do not delete this directory and make sure it is included in your repository.
Many projects have a standard “.*” rule in .gitignore to ignore all files and directories that start with a dot. However, we want to ensure the Kiro directory (which starts with a dot) is NOT ignored. Therefore, add !.kiro to the end of the repository’s .gitignore file so it is not ignored.
Steering documents
Steering documents are authoritative, human-authored constraints that guide AI-assisted engineering. They define platform standards, architectural decisions, naming conventions, testing expectations, and operational requirements to ensure AI-generated outputs remain aligned with institutional practices.
It is good practice to have a set of steering documents that you bring to your project. Kiro can utilize steering documents at the project level (within the repo) and at the global user level (within your home directory). If you do not find a steering document that meets your needs, take some time creating one before you begin development. These are as important as your plan and specs. Never start a new plan or spec with an empty .kiro/steering directory.
Ways to obtain steering documents:
- Within a project, you can even prompt Kiro to generate a steering document that ensures it performs/uses/incorporates x, y, and z.
- Some repositories include an AGENTS.md file in the root of the repo. Kiro will pick this up and include it as if it were a steering document. Generic, project-wide requirements can be added here.
- Check with the Cloud Team to see if there are example repositories that may have relevant steering documents for your repository.
- When using the Atlantis DevOps Platform to scaffold your project, you can utilize the steering documents provided in the application starter or by asking the Atlantis MCP to recommend and then download a selection of steering documents from the Atlantis library.
Example steering topics:
- Color palette for front-end design
- Accessibility requirements
- Testing requirements and framework
- Documentation requirements and structure
- Manually run Node/Python package updates
Learn more about Kiro Steering Documents
Kiro Hooks
Kiro hooks are saved prompts that run based on automated triggers during file save, commit, or other events to enforce standards, run tests, or update documentation without manual intervention.
Like steering documents, you can have Kiro create a hook for you if you have a specific request.
Learn more about Kiro Hooks
MCP Servers
MCP servers can assist Kiro in discovering documentation and patterns. Some are installed locally, while some connect to a remote server. Be aware of the implications of adding unverified servers.
Recommended MCP Servers:
- AWS Documentation
- Context7
- Terraform (If you use Terraform)
- Atlantis DevOps Platform MCP (documentation and patterns for developing with the Atlantis DevOps Platform)
The Kiro site maintains an MCP Server directory.
Learn more about MCP on Kiro
Using Kiro
From AWS Kiro YouTube Channel: Transform Your Development Workflow with Kiro (4 minutes)
From AWS Kiro YouTube Channel: 3 Credit-Smart Strategies to Maximize Kiro’s Potential (5 minutes)
While Kiro will formalize and generate many requirements, design, and task documents, it helps to come to Kiro with a well-defined project.
Gather the following and formulate a document written in markdown:
- Plan (use Kiro as a thought partner to think through requirements and architecture before generating specs)
- Specs and Requirements
- Expected Outputs
- Proper terminology
- Well-defined business logic
- Existing documentation
It may take a day or two to create the document, which will serve as your prompt. Use this time to ensure you clearly understand the project and frame it properly. Use Markdown to your advantage with headings, ordered and unordered lists, and a logical structure. The document doesn’t need to be perfect (it may resemble notes); Kiro will take it (attach it to your initial prompt) and then create formal documents. Include examples of external APIs, queries, code snippets, etc. Take time to research and gather everything you need. You don't need to write a professional spec. Thoughts, notes, terms, and ideas, you'll turn this over to Kiro to do the Project Management work.
Remember: AI prompts are limited in context and tokens; it is best to present complex ideas in a document attached to (or mentioned in) the prompt. This allows you time to review and raise clarifying questions with stakeholders before submitting.
Do All the Things (Tests, CI/CD, Documentation)
You’re Now A 1,000x Developer and Cloud Engineer! Now you have time to do everything right!
The final 10% of development is always left until the end and accounts for more than 90% of the effort. It waits until the end because it is not fun, and it hardly ever gets done before the next project starts.
Luckily, you no longer need to do this alone. AI excels at these tasks (and never procrastinates!) by generating documentation and tests alongside code and infrastructure.
The following would be great to include in a steering document (if applicable to your project!):
Write tests and documentation, as well as local and CI/CD scripts, from the start and keep them updated throughout the process by adding tasks at appropriate milestones. Always run all tests to ensure they pass. Ensure builds and tests run successfully both locally and during automated deployments.
Resources:
How to Use Kiro, the New Agentic IDE (by Syntax on YouTube)
Scott Tolinski from Syntax talks about his move from Cursor to Kiro and how he enjoys the Spec Driven Development process (40 minutes).
Provides an overview of the interface, steering, specs, agent hooks, MCP servers, and building a demo app.
Kiro Live: Spec driven development in the evolving tech landscape (KiroDotDev on YouTube)
Explore how AI is changing software development by comparing rapid, prompt-based vibe coding with structured, spec-driven methodologies. See live demonstrations of building accessible applications and complex storage systems using these evolving techniques. (60 minutes)
Kiro Workflow (by Chad on YouTube)
Our DevOps and Developer Experience Engineer, Chad, has also posted a video demonstrating the importance of iterating: "Iterate: AI-Assisted Planning and Design (with Kiro)" (blog post with 27min on YouTube).
He spends time iterating over questions and using generative AI and Kiro as a thought partner before writing specs. This ensures his ideas going into a project are challenged and guided by best practices to produce a sound planning document. The planning document then serves as the starter document to serve as a prompt and invites Kiro to ask questions about the spec, not in the prompt window but in a separate document that allows it.
Chad has also curated a playlist of Kiro videos from other channels.