Zero to shipped - a year in review

Source: Dev.to

Overview

I’m sharing the notes and resources from my “Zero to Shipped in 30 minutes” live‑coding talk at Build Stuff. The goal was to demonstrate how, with a next‑generation AI coding assistant (Kiro + Kiro CLI), you can go from an empty project to a production‑ready fact‑checking app deployed on AWS in half an hour.

The talk was recorded; the video will be posted on the Build Stuff YouTube channel soon. In the meantime, you can explore the code and the supporting material:

• Resources repo:
• Finished application:

Good Practices for Steering Documents

Steering documents let you shape Kiro’s behavior to match your personal workflow. They are simple markdown files stored in a dedicated directory inside your project workspace.

Core recommendations

• Keep them small and focused. Smaller documents stay within LLM context windows and produce more reliable results.
• Update them regularly. Treat steering docs as living artifacts—edit and curate them as your workflow evolves.
• Use multiple documents as needed. You can have separate files for coding standards, deployment, API design, etc.
• Organise by domain. Domain‑specific steering docs (e.g., coding‑standards.md, deployment.md) are easier to maintain.
• Start small. Begin with a minimal set of rules and expand gradually; avoid dumping everything at once.
• Control inclusion. Kiro supports different inclusion modes (always, on‑demand, etc.) so you can decide when a document influences the model.

Example Steering Document

The following snippet is the steering document I use in every project. It encodes my preferred Python stack, project layout, and package‑management conventions.

---
inclusion: always
---

# Coding Preference

You have a preference for writing code in Python. 

## Python Frameworks

When creating Python code, use the following guidance:

- Use Flask as the web framework
- Follow Flask's application‑factory pattern
- Use Pydantic for data validation
- Use environment variables for configuration
- Implement Flask‑SQLAlchemy for database operations

## Project Structure and Layout

    app/
    ├─ src/
    │  ├─ static/
    │  ├─ models/
    │  ├─ routes/
    │  ├─ templates/
    │  └─ extensions.py

## Local and Prod Configurations

- Run local development on `127.0.0.1:5001`
- Run production via Gunicorn
- Configure everything through environment variables

## Python Package Management with **uv**

- Use **uv** exclusively for all dependency handling.
- All dependencies must be installed, synchronized, and locked with uv.
- Never use `pip`, `pip‑tools`, Poetry, or Conda directly.
- Common commands:

  ```bash
  # Install a package
  uv add <package>

  # Remove a package
  uv remove <package>

  # Sync lockfile
  uv sync

  # Run a script
  uv run <script>.py

  # Run tools (pytest, ruff, etc.)
  uv run pytest
  uv run ruff

  # Open a REPL
  uv run python

• Configure [tool.hatch.build.targets.wheel] in pyproject.toml as appropriate for the project.

## Automation with Kiro Agent Hooks

Kiro can react to file‑system events (creation, save, deletion) via **Agent Hooks**. This lets you automate repetitive tasks such as adding license headers to new source files.

### Sample Hook: Add SPDX & Copyright Headers

Place the JSON file below in the `.kiro/hooks` directory of your workspace. Kiro will prompt the model to insert the required header whenever a new Python file is created.

```json
{
  "enabled": true,
  "name": "Add License Headers",
  "description": "Automatically adds SPDX 2.0 headers for Apache 2.0 license and copyright notice '(C)opyright 2025 BeachGeek.co.uk' to Python files when they are created or edited",
  "version": "1",
  "when": {
    "type": "fileCreated",
    "patterns": [
      "**/*.py"
    ]
  },
  "then": {
    "type": "askAgent",
    "prompt": "Check if this Python file has the proper SPDX 2.0 license header for Apache 2.0 and the copyright notice '# (C)opyright 2025 BeachGeek.co.uk'. If missing, add them at the top of the file in the correct format: SPDX-License-Identifier: Apache-2.0 followed by the copyright line."
  }
}

When the hook fires, Kiro inserts a header like:

# SPDX-License-Identifier: Apache-2.0
# (C)opyright 2025 BeachGeek.co.uk

You can adapt the hook to other languages, different licenses, or any boiler‑plate you need.

Using Images as Context

Beyond text, Kiro can ingest images to provide visual context for code generation. In the demo I uploaded an entity‑relationship diagram (ERD) of the fact‑checking data model and asked Kiro to produce the corresponding SQL schema.

Prompt used:

Generate the data model in SQL from the ERD diagram. Store it in the data-model directory, in a file called fact-checker.sql.

Within seconds Kiro created data-model/fact-checker.sql with the full schema. This illustrates how you can turn architecture sketches, whiteboard photos, or UI mockups into executable artifacts simply by attaching the image and prompting the model.

Takeaways

1. Steering documents give you fine‑grained control over an AI assistant’s output. Keep them concise, modular, and up‑to‑date.
2. Agent Hooks automate repetitive developer chores, ensuring consistency across the codebase.
3. Image‑based prompts unlock a new workflow where visual designs directly drive code generation.

Feel free to clone the repos, experiment with the steering docs and hooks, and let me know how you adapt them to your own development style. Happy coding!