AWS Builder Center

Builder Center

LUMEN — Week 0: Building the Foundation Before Writing Code

LUMEN — Week 0: Building the Foundation Before Writing Code

Follow my journey building LUMEN, an ambient AI companion for blind and low-vision users, while learning AWS, Strands Agents, DevOps, and AI/ML.

Series: LUMEN - Ambient AI companion for blind and low-vision users. (2 articles)

  1. 1
    AWS Agents for Humans Hackathon
  2. 2
    LUMEN — Week 0: Building the Foundation Before Writing Code This article
In my previous article , I shared how I discovered the AWS Agents for Humans Hackathon, teamed up with a friend, and ultimately decided not to participate.
We had a project idea, but by the time we finalized it, less than a week remained. Building a prototype with AI coding tools was possible, but my goal wasn't just to build something quickly. I wanted to learn AWS properly.
So, instead of rushing toward a deadline, I turned the idea into a multi-week personal project.
That project is LUMEN.

What is LUMEN?

LUMEN is an idea for an ambient AI companion designed for blind and low-vision users.
Imagine a voice-operated assistant that uses a phone's camera to understand its surroundings and gradually builds a memory of familiar places — your home, your workplace, or your regular walk to the bus stop.
Rather than constantly describing everything, it would ideally stay quiet most of the time and alert you when it detects something potentially important, such as stairs or an unexpected step down.
The goal is to move beyond one-off image descriptions toward an assistant that understands context over time.
This is still a vision, not a working system. Building it will require exploring computer vision, agent orchestration, persistent memory, cloud infrastructure, privacy, and safety.
And that's exactly why I want to work on it.

Week 0 — Before writing code

Instead of immediately building AI agents, I started with the foundations.
I wanted LUMEN to be more than a collection of scripts. Even as a solo project, it should have the structure, documentation, and development practices of a maintainable open-source repository.
Here's what I completed.

Repository and documentation

  • Public GitHub repository: Created a public home for the project and its development history.
    You can access it by clicking here. 
  • MIT License: Established the project's licensing terms using the Choose a License guide .
  • README.md: Added the project pitch, early-development status, an initial architecture overview, and a table of contents.
  • CONTRIBUTING.md and CODE_OF_CONDUCT.md: Documented contribution expectations and community guidelines, using the Contributor Covenant  as a reference.
  • SECURITY.md: Added a policy for reporting vulnerabilities, particularly important for a system that may handle camera, voice, and location-related data.
  • CHANGELOG.md: Adopted the Keep a Changelog  format to track notable changes as the project evolves.

Development workflow

  • .gitignore: Added exclusions for Python-generated files, environment variables, private keys, and local credentials, using GitHub's Python template  as a starting point.
  • Conventional Commits: Adopted prefixes such as feat:, fix:, docs:, and chore: to keep commit history readable. See the Conventional Commits specification .
  • Branch protection: Configured rules for main that require pull requests, even when working alone. The idea is to review changes before merging them.
  • Project structure: Created the initial directories for application code, infrastructure, documentation, tests, and GitHub Actions workflows.
The structure currently looks like this:
1
2
3
4
5
6
7
lumen/
├── .github/
│ └── workflows/
├── docs/
├── infra/
├── src/
└── tests/
These directories are intentionally empty for now. They'll provide a home for the application, infrastructure as code, tests, documentation, and automation as development progresses.
Learning Git
I also identified Pro Git , a free online book, as a resource for strengthening my understanding of Git fundamentals.
Branches, commits, pull requests, and merges might seem like small details, but learning to use them properly is part of becoming a better software engineer.

What did I learn?

Week 0 wasn't about building an AI agent. It was about preparing to build one properly.
I learned that documentation, licensing, security policies, and repository organization aren't just administrative tasks. They're part of creating software that other people can understand, use, and potentially contribute to.
I also wanted to establish good habits before the project became more complex. It's easier to introduce a structured workflow at the beginning than to retrofit one later.
Most importantly, I gave myself permission to learn at a sustainable pace rather than rush toward a hackathon deadline.

What's next?

With the repository foundations in place, the next stage is to start exploring the technologies that could power LUMEN.
My learning journey will focus on three areas:
  • AWS Cloud: Cloud services, permissions, and infrastructure.
  • DevOps: Infrastructure as code, automated testing, and CI/CD.
  • AI/ML: Strands Agents, agent orchestration, multimodal interaction, and persistent memory.
I'll evaluate the architecture as I learn rather than committing to technologies before understanding their trade-offs.
Each week, I'll share progress, challenges, and lessons learned — including what doesn't work.

Follow the journey

LUMEN began as an idea for the AWS Agents for Humans Hackathon. Although I decided not to rush into a last-minute submission, I didn't want the idea to end there.
Instead, I'm turning it into a longer learning journey: one in which the engineering process matters just as much as the final result.
If you're interested in AWS, agentic AI, DevOps, or accessibility-focused technology, follow along as I build LUMEN from the foundations upward.
Project: LUMEN — Ambient AI Companion for Blind and Low-Vision Users 
Hackathon that inspired the project: AWS Agents for Humans Hackathon 
Resources referenced in this article:
This is the second article in the LUMEN series. Next up: moving from repository setup toward the first technical milestones.
# ai-agents# strands-agents# social-good# learning-and-development# open-source

Series: LUMEN - Ambient AI companion for blind and low-vision users. (2 articles)

  1. 1
    AWS Agents for Humans Hackathon
  2. 2
    LUMEN — Week 0: Building the Foundation Before Writing Code This article
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article