Zero Coding, Zero Budget

What if you could build a working, complex, market-ready prototype entirely for free, using only open-source tools and a powerful new AI workflow system?

In this deep-dive guide, we are going to prove it. We will take a simple idea and walk through the complete product pipeline: from defining the requirements (PRD) to generating and executing the full codebase. You won’t need to know how to code; you just need to follow the steps.

Let’s build a functional prototype using the command line, open-source tools, and a powerful orchestrator skill.

The Problem

Before we touch a single line of code, let’s define the problem. (pick your own adventure)

The Problem: For policyholders, updating an insurance policy often requires them to provide the bank details (lienholder information) of the paying institution. Finding this information is usually fragmented, requiring manual searches across multiple government sites, proprietary databases, or paid data services.

Target Audience: Policyholders and Customer Service Representatives

Core Features: Parse, normalize, and unify disparate lienholder documents into a single, searchable database.

The Solution: A free, centralized web service that ingests public documents (PDFs, XLSs, HTMLs) from various sources, extracts the critical bank information (bank name, address, city, state and zip code), and normalizes it into a clean, searchable JSON format.

The Toolkit

We are leveraging a set of open-source tools designed to handle the complexity of modern development pipelines without much human intervention.

• Opencode: is an open source agent that helps you write code in your terminal, IDE, or desktop.
• Get Shit Done Skill (gsdl): This set of pre-built skills runs the entire project pipeline automatically: Project Setup → Create PRD → Create Plan → Execute Plan.

The Setup

This section contains all the setup commands. Do not skip these. You need to execute them sequentially in your terminal.

# Setup steps:

# Install Opencode: 
curl -fsSL https://opencode.ai/install | bash

# Create Agents / Skills Directory:
mkdir ~/.agents/ && cd ~/.agents/ && mkdir skills/ && cd skills/

# Download and Place the Skills:
curl -O https://howdyitskyle.com/gsdl.zip && unzip gsdl.zip 
(Skills has: gsdl, gsdl-setup-project, gsdl-create-prd, gsdl-create-plan, gsdl-execute-plan)

# Create Directory for Project:
mkdir ~/Projects/ && cd ~/Projects/ && mkdir lienholder/ && cd lienholder/
(Example folder structure)

Phase 1: Defining the Product (PRD)

Run the opencode command in the terminal from inside the project folder. Hit crtl + p and type skills and hit enter to select it. Next select the skill gsdl Get Shit Done (GSD) orchestrator and hit enter. The slash prompt should appear in the textarea, start by hitting enter to run the workflow.

Now we just follow the prompts given to us by opencode to start our product journey. As mentioned before, the skill will have us answer planning questions to create our PRD and task list in which it will execute against. Try to provide as much context as possible for the best outcome.

After walking through the first phase we can view the PRD inside of the .planning folder and edit it. Changes if any will be picked up automatically.

Phase 2: Generate Task List

Based on our PRD, our task list looks like this:

• 1.0 Set up Vite + React + TypeScript project with Tailwind and shadcn/ui
• 2.0 Inspect source data files and create data parsing scripts
• 3.0 Generate normalized JSON data file
• 4.0 Implement search/filter component with real-time updates
• 5.0 Build lienholder card component with copy-to-clipboard
• 6.0 Create main page layout with pagination
• 7.0 Polish UI, responsive design, and accessibility

If everything looks good, respond with Go to generate the sub-tasks. Before proceeding, review the task list file inside the .planning folder and make any edits.

Phase 3: Implementation

Prompting Go starts the process of implementation according to the task list. After each task is complete, opencode will ask to advance to the next step. Proceed through the steps and wait for the final output. Subagents spawn to help with the various subtasks associated to each task, creating a very quick and efficient implementation.

Once finished, a message should appear confirming all tasks have been completed.

In another terminal, run the command npm run dev and the dev server will start. A live, interactive mock-up will be available in the browser at http://localhost:5173. (this might be different depending on what is built)

Troubleshooting

What if a step fails?

The system is designed to fail gracefully. When an error occurs, it provides a specific stack trace and context, allowing you to debug the precise point of failure, much like a team pairing session.

Is this magic?

No. It is an advanced software development lifecycle automation tool. It automates the scaffolding, boilerplate, dependency management, and initial scaffolding required for complex applications, significantly reducing development time from weeks to hours.

Do I still need to be a developer?

While the tool does the heavy lifting, understanding the architecture and being able to guide the PRD process is critical. You become the Product Owner rather than the Code Monkey.

Can I pickup where I left off?

When you quit your project, opencode will give you a session ID (opencode -s your-session-id). Remember to copy this and use it to revisit the project for updates and tweaks.

How can I improve the design?

Visit skillsmp and find a design skill to help! Just drop the skill in the ~/.agents/skills/ folder. Then simply select the skill, thats it.

In essence, this workflow allows a non-developer to direct a software engineering team using an automated, iterative, and review-gated process.