Most professional journeys begin with a plan.
Mine began with the Final Mile Setup slide deck, an existing software repository, several unfamiliar tools, cloud access, deployment permissions, and a collection of Star Trek-inspired prompts that I was somehow expected to remember.
To say that I felt overwhelmed would be an understatement.
But that is also what makes this journey worth documenting.
This post marks the beginning of my Journey Through Alchemy SDLC, a blog series where I will share my experience learning Alchemy SDLC through hands-on work. My goal is partly personal: I want to document how my skills, responsibilities, and understanding develop over time. However, I also want these posts to become a resource for others who may eventually find themselves standing at a similar starting point.
I am not beginning this series as an expert who already has everything figured out.
I am beginning it as someone who understands many of the ideas behind the software development lifecycle but is now learning how those ideas come together inside a real AI-assisted development process.
And before going any further, there is one thing I want to make clear:
It is okay to feel overwhelmed!
What It Takes to Get Started
Before I could begin making changes to an application, I first had to work through the Final Mile Setup. The process covered account configuration, permissions, local development tools, repository access, cloud services, authentication, and deployment capabilities. Each item was necessary because Alchemy SDLC does not operate in isolation. It works across the tools and environments involved in building, testing, documenting, and releasing software.
That meant confirming that I could access the correct GitHub repository, authenticate through the required accounts, use the necessary command-line tools, connect to the cloud environment, and set up Docker for deployments.
None of those individual tasks sounded unreasonable.
Taken together, however, they made the starting point feel much larger than I expected.
There was not one new tool to learn. There were several.
There was not one account to configure. There were multiple accounts, roles, and permissions.
There was not one application to understand. There was an existing repository containing code that already supported something valuable.
On top of all that, I was being introduced to the idea that much of the application would be maintained and enhanced through conversations with AI rather than through the traditional process of manually writing every line of code.
The setup deck helped establish the starting line, but it did not immediately make the path feel simple.
The Overwhelming Part
Part of what overwhelmed me was the scope of everything I was seeing at once.
I was looking at an established application, its source code, cloud infrastructure, deployment process, documentation structure, testing expectations, and AI workflow. I understood pieces of each area, but I did not yet understand how all of those pieces connected.
There was also the weight of knowing that the code in front of me mattered.
This was not an empty practice repository created for a tutorial. It was an existing application with real functionality. Any future enhancement would need to preserve what already worked while adding something new.
Then there was the idea of managing that work through AI.
The fear of breaking something and not being able to fix it.
The thought of having to go to my lead AND TELL THEM I BROKE SOMETHING!
I was familiar with using AI to generate content, answer technical questions, explain errors, and assist with isolated coding tasks. Alchemy SDLC introduced something broader. Instead of asking AI to produce a quick code snippet, I would be learning how to use it across the lifecycle of an application.
That includes defining enhancements, guiding implementation, reviewing and testing the results, documenting changes, and preparing the application for deployment.
The AI may perform much of the technical execution, but that does not eliminate the need for human direction or judgment.
I still need to understand what I am asking for.
I still need to recognize whether the output matches the requirement.
I still need to test the result.
I still need to know when something does not look right.
That responsibility can feel intimidating when you are still learning the process. But feeling overwhelmed does not mean you are incapable. Sometimes it simply means you have been introduced to a large amount of new information at once.
Learning the Language of the Workflow
You do not have to understand the entire system on the first day. You only have to begin learning the next part.
Alchemy SDLC uses a Star Trek-inspired workflow. Features and enhancements are organized as episodes. Riker helps coordinate the work. Different members of the virtual crew perform different responsibilities, such as reviewing security, infrastructure, logic, APIs, diagnostics, and implementation decisions. There are also specific phrases connected to particular actions.
“Make it so” means to proceed.
“Engage” is associated with deployment.
“Scan for life forms”, one of my favorites, starts a more complete testing process based on the documented instructions for how the feature, or rather, the episode, should be tested. Yes, there are episodes!
“Director’s Dimension” provides a consolidated output of the work in a film-style format.
At first, these phrases add another layer of uncertainty.
I am not only learning what needs to happen during the development process. I am also learning how to communicate with the AI system so that it performs the correct process at the correct time.
Which prompt should I use?
How much detail should I provide?
When should I let the system continue, and when should I stop to review its work?
How do I know whether the AI completed every required step?
These are the types of questions that naturally appear when learning a new workflow.
Again, it is okay to feel uncertain.
The prompts may sound simple, but the real skill is understanding what each one causes the system to do. Over time, the terminology should become familiar. The sequence should begin to make sense. What initially feels like a collection of unusual commands should eventually become a repeatable development process.
But I am not there yet.
That is the point of this series.
Learning in Public
I could wait until I feel completely comfortable with Alchemy SDLC and then present a polished summary after everything makes sense, but I believe there is more value in documenting the process while it is happening.
The early uncertainty matters.
The confusing setup steps matter.
The first error message matters.
The moment when a command finally works matters.
The difference between what I expected and what actually happened matters.
Someone else beginning this process may experience the same uncertainty. They may look at the repository, the cloud environment, the AI workflow, and the unfamiliar terminology and wonder whether they are already behind.
I want this series to show that being unsure at the beginning is normal.
My posts will not pretend that every task went smoothly. When I encounter a blocker, I will explain it. When I misunderstand part of the workflow, I will share what corrected that misunderstanding. When something begins to click, I will explain what helped me understand it.
This will be a record of progress, not perfection.
What Comes Next
My first hands-on experience with Alchemy SDLC involves maintaining and enhancing one of our existing internal applications. That environment will allow me to become more comfortable with the tools, prompts, documentation, testing approach, and deployment process before moving into larger application builds.
Future posts may cover topics such as:
- Preparing the local development environment
- Understanding an Alchemy SDLC repository
- Defining an enhancement as an episode
- Communicating requirements to the AI crew
- Reviewing and testing AI-generated changes
- Troubleshooting version control and deployment problems
I expect those topics to change as the journey progresses. Some of the most useful lessons will probably come from problems I do not know enough to anticipate yet.
That uncertainty no longer feels like a reason not to begin.
It feels like the reason to keep writing.
Moving Forward Without Having Every Answer
I do not yet know every tool, remember every prompt, or understand every part of the repository and deployment process.
I am still learning how much direction the AI needs and how to review the decisions it makes.
But I am ready to learn.
That may be the most important lesson at the beginning of any new technical journey: confidence does not require certainty.
You can feel overwhelmed and still move forward.
You can be unsure and still ask the next question.
You can begin before you understand the entire system.
This series will document what happens when I do exactly that.
The setup is complete. The tools are configured. The repository is open. The prompts are still unfamiliar.
And the journey through Alchemy SDLC has officially begun.