Brain in a Jar

Kiro + Claude Sonnet = better than a spare brain in a jar. Kiro, the AI native IDE went into public preview on July 15, 2025 and was immediately so popular there was a waiting list. I made it off the waiting list a few days ago and was anxious to give it a try.

There are two suggested paths to start with, “Vibe” coding or “Spec” coding.

My first trial was on the side of vibe coding. I’ve been playing with ways to make RAG and knowledge bases more cost effective to implement. (Yes, I may have left a hosted knowledge base up and running a little longer than I should have.) I asked Kiro to help me develop vector databases with Langchain and integrate database storage in AWS.

One of Kiro’s tag lines is “ Build something real in minutes”. This was certainly my experience. In about twenty minutes I had a completely functional program to create vector databases and three alternate ways to store them in AWS, complete with pricing for the three options.

Kiro took my initial prompt “I would like to use Langchain to create a vector database” and created a workspace with options for a simple Chroma database and a more complex vector database that loads documents from files, does metadata filtering, score thresholds, and collection statistics.

I ran the initial suggested option for the simple database and received an error- “ImportError: cannot import name ‘cached_download’ from ‘huggingface_hub’ (/home/mom/Desktop/august9/.venv/lib/python3.12/site-packages/huggingface_hub/__init__.py)’.”

I gave Kiro this error and it determined that there was a version compatibility issue with the huggingface_hub library. Kiro updated my requirements.txt file and prompted me to reinstall the dependencies.

Both the simple version and the advanced version of the program now ran flawlessly and I asked Kiro: How do I store these vector databases in an AWS S3 vector database? I received suggestions for three different options and the price breakdown for each.

🚀 AWS Vector Database Options

1. FAISS + S3 Storage (aws_vector_db.py)
   
   Best for: Cost-effective storage and moderate scale
   
   How it works: Create FAISS indexes locally, upload to S3 for backup/sharing
   
   Benefits: Low cost, simple setup, works with existing FAISS code

2. AWS OpenSearch (aws_vector_db.py)
   
   Best for: Production applications needing real-time search
   
   How it works: Managed OpenSearch cluster with vector search capabilities
   
   Benefits: Fully managed, scalable, real-time indexing

3. AWS Bedrock Knowledge Base (aws_bedrock_vector_db.py)
   
   Best for: Enterprise applications with managed AI services
   
   How it works: Fully managed vector database integrated with Bedrock models
   
   Benefits: Zero maintenance, automatic document processing, integrated with LLMs

All very cool. Now I wanted to try the Spec coding style. I used the same initial prompt and secondary requirement — a Langchain vector db with s3 storage. Kiro quickly produced a design, project summary, requirements, and tasks — see

https://github.com/mgbec/Kiro-langchain-vector-spec/tree/main/specs/langchain-vector-database

I added an additional requirement of observability and security and Kiro ran the “spec-timization/spec-torization” process. No reference to Phil Spector intended here.

Kiro created updated design, requirements, and tasks documents with some pretty awesome security and observability spec’d out.

https://github.com/mgbec/Kiro-langchain-vector-spec-secure/tree/main/specs/langchain-vector-database

Security Features

 —  Authentication: API key and JWT token-based authentication systems

 — Authorization: Role-based access control (RBAC) with granular permissions

 — Data Protection: Encryption at rest and in transit with AES-256-GCM and TLS 1.3

 — PII Detection: Automatic detection and masking of personally identifiable information

 — Security Monitoring: Comprehensive audit logging, rate limiting, and intrusion detection

 — Secure Configuration: Safe handling of credentials and sensitive configuration data

Observability Features

 —  Structured Logging: JSON-formatted logs with correlation IDs and context propagation

 — Comprehensive Metrics: System, application, and business metrics collection

 — Distributed Tracing: OpenTelemetry integration for end-to-end request tracking

 — Health Monitoring: Health check endpoints and system status monitoring

 — Performance Analysis: Memory, CPU, and I/O monitoring with alerting capabilities

 — Debugging Support: Detailed error traces and performance bottleneck identification

I finally told Kiro to go ahead and implement the plan. Kiro systematically went through and created the system, following tasks.md. I was initially prompted if I wanted to review the structure after each task, until I told Kiro to run each task without prompting. Probably not something you would do in a production environment, but fine in this instance.

The building process was very quick (under two hours), but I did end up with a time out on the sessions several times. This is where the tasks.md structure is invaluable. When my session was timing out, Kiro would create a summary and start a new session. The new session checked existing files and worked on the next task.

The end result is first, some very thorough documentation:

— design.md (https://github.com/mgbec/Kiro-langchain-vector-spec-secure/blob/main/specs/langchain-vector-database/design.md)

— project-summary.md (https://github.com/mgbec/Kiro-langchain-vector-spec-secure/blob/main/specs/langchain-vector-database/project-summary.md)

— requirements.md (https://github.com/mgbec/Kiro-langchain-vector-spec-secure/blob/main/specs/langchain-vector-database/requirements.md)

— tasks.md (https://github.com/mgbec/Kiro-langchain-vector-spec-secure/blob/main/specs/langchain-vector-database/tasks.md)

Secondly, we have the Kiro produced code, with complete documentation, examples, tests, and more. https://github.com/mgbec/Kiro-langchain-vector-spec-secure/tree/main/KiroSpec

Some other features of Kiro that are exciting are Agent Steering and Agent Hooks.

Agent Steering  — this is a way to guide your agents in a way specific to this project. You can have it produce three foundational files:

“product “— which is a product overview with key features, target use cases, and more

“structure” — directory structure, test structure, naming conventions and additional items

“tech” — core technologies, key dependencies, build system, common commands, dev setup, testing, code quality, env variables, configuration patterns

You can also customize the steering with other files and inclusion modes.

Agent Hooks - you can create event driven actions here, for example, update documentation when a file is created:

MCP Servers- there is a dedicated pane for these, which I like better than digging through config files.

In summary, Kiro’s vibe coding is great, but the spec driven design, in particular, seems pivotal in an enterprise environment. The easily created documentation and logical tasks make my Spock-like little heart very happy. It seems like a welcome addition to security documentation and architectural review boards, as well.