Becoming AI Native: How we teach our non-technical team to build with AI

A practical walkthrough from DevLabs by AngelHack

Introduction

A common question we get from founders and product teams is: “How far can I realistically get without knowing how to code?”

Historically, the answer was: not very far. You could plan, but you still needed engineers to turn ideas into something tangible. Today, that boundary has shifted.

Today’s tools, from no code platforms to AI assisted development environments, make it possible to prototype ideas, test workflows, and ship early versions of products without writing a single line of code. This lowers the barrier to entry, shortens feedback loops, and allows teams to focus on solving user problems rather than getting blocked by engineering complexity.

The main bottleneck for using no code development tools is clarity, structure, and decision-making. If you can explain what you want clearly, AI can increasingly handle the heavy lifting of documentation, scaffolding, and even implementation.

We use a simple, repeatable setup internally that allows even non-technical team members to go from idea → brief → specs → working prototype.

In our second series of “Becoming AI Native”, we go through a practical walkthrough of that same setup. The goal isn’t to teach programming, but to help you create an environment where AI can actively collaborate with you.

What you’ll learn:

• One-time setup
• How to go from idea → documentation → working prototype
• When you actually need to hire a developer
• Common mistakes and how to avoid them

“Startups using AI-assisted tools are launching functional MVPs in just 2 to 6 weeks – that’s roughly 10 times faster (than before AI adoption).” RapidNative

Setup phase

Preparing your workspace (one-time only)

The purpose of this phase is to create a local environment where AI can read, write, and manage your project files.

After setup, you’ll have:

• A workspace (VS Code)
• An AI coding assistant (Claude Code)
• A structured product framework (BMAD)

1. Install VS Code: Setting Up Your Workspace

Before AI can help you build anything, you need a place where your project lives. VS Code acts as that workspace. Think of it like a shared desk where your files, documentation, and AI assistant all come together.

• Download Visual Studio Code: https://code.visualstudio.com/
• Move it to Applications (for macOS)
• Open it

Purpose: This is your home base. All documents, specs, and code will live here.

2. Install the Claude Code extension

Next, connect an AI assistant directly into your editor.

Inside VS Code:

• Go to Extensions (left sidebar, looks like blocks)
• Search Claude Code
• Install
• Log in with your Claude account

This step is important because it changes AI from a chat tool into an active collaborator. Instead of copying answers from a browser, the AI can now create and edit files directly inside your project.

Purpose: Allows AI to work inside your codebase.

3. Open the Terminal inside VS Code

The terminal lets you install tools and create projects.

• Terminal → New Terminal

You won’t need to memorise commands. For this guide, you’ll mostly paste a few lines.

Purpose: Used for installing dependencies and running setup commands.

4. Install Node.js (dependency)

Some development tools rely on Node to run locally. It enables package installation.

• Download from https://nodejs.org/en

After installing, verify it worked:

node -v

You should see something like:

v20.11.0

If you see a version number, you’re set.

Purpose: Enables npm/npx so frameworks like BMAD can be installed.

5. Create a project folder

Now create a dedicated space for your project.

In Terminal:

cd Desktop
mkdirtest
cdtest

Then open this folder in VS Code.

• File → Open Folder
• Select ‘test’

You should see this in the left sidebar.

This becomes the location where everything is generated: documentation, specs, and code.

Purpose: Keeps all project files organised in one place.

6. Install the BMAD framework

At this point, you could already chat with AI, but the experience would feel unstructured. BMAD changes that. It adds predefined “roles” that mirror a real product team.

Why We use the BMAD agent:

→ The BMAD agent guides this step through structured prompts about target users, pain points, and expected behaviour. These inputs are then translated into clear functional and non-functional requirements, providing a solid foundation before breaking work into epics and stories.

→ These frameworks define clear roles: business analyst, product manager, engineer

• Analyst: Asks structured questions to clarify your idea (“Who’s your user? What problem are you solving?”)
• Product Manager: Turns your answers into proper requirements and user stories
• Architect: Designs how the system should work
• Developer: Writes the actual code

Without BMAD, you’re chatting freely and hoping for good results. With BMAD, you follow guided workflows that mirror how real product teams operate, from business analysis through implementation.

Visit: https://github.com/bmad-code-org/BMAD-METHOD and scroll down until you see this:

Run:

npx bmad-method install

During setup:

• accept most defaults
• when prompted for editor, choose Claude Code

After installation, you should:

• see new folders such as docs/ or bmad/
• be able to type /bmad and see agent options

Purpose: Adds structured AI roles (Analyst, PM, Architect, Dev) that guide the product workflow.

At this stage, setup is complete. You now have:

• a workspace
• an AI coding assistant
• a structured product framework

Now you can start building.

Usage phase

Turning ideas into product artefacts

The goal of this phase is to move from idea to MVP systematically. AI helps you create the same artefacts a traditional product team would produce, but faster.

7. Open Claude Code inside VS Code

Click the Claude icon in VS Code.

This opens your AI assistant directly inside the project. Any files it generates will appear instantly in your folder.

Purpose: Central place to interact with AI.

8. Load an AI role (agent)

Start with the Analyst: turn ideas into clarity

Most MVPs don’t fail because of bad code. They fail because the requirements were unclear.

So instead of jumping straight into development, we start with analysis.

Loading the Analyst agent gives you a set of guided workflows, including “Create Brief”. Rather than writing a blank document yourself, the AI asks structured questions and builds the brief with you.

Type:

/bmad analyst

This loads the Analyst agent and presents a list of guided workflows rather than a blank chat.

Start with Create Brief.

The agent walks you through a series of questions:

• Who is your target user?
• What specific problem are they facing?
• What does success look like?
• What are your constraints (time, budget, technical limitations)?

This ensures you have clarity before moving into implementation.

Purpose: Structures thinking before building.

9. Generate your documentation

The BMAD Agent will guide you through

• Defining requirements
• Creating a PRD
• Breaking work into epics and stories
• Implementing a working application

As you answer the agent’s questions, AI will:

• ask follow-ups
• organise your thoughts
• create files automatically

You’ll see documents like:

• README
• product brief
• PRD
• requirements

appear directly in your project.

Instead of writing everything manually, you review and refine what AI produces.

Purpose: Quickly create the foundation needed for development.

10. Progress through roles

Once the brief is complete, you move through the workflow:

Analyst → PM → Architect → Dev

Shaping Workflows: Product Brief (BA) PRD (PM) UX Specification (UX) Architecture (Arch) Epics & Stories (PM)

Implementation Workflows: Sprint Planning (SM) Create Story (SM) Dev Story (Dev)

By the end, you’ll have both documentation and working code.

To switch roles:

/bmad pm /bmad architect /bmad dev

Each agent will guide you through their specific workflows

Purpose: Provides a structured path from idea → MVP.

Time and Cost Expectations

Set up phase: 30-45 minutes (one time only)

Documentation phase: 2-4 hours

First working prototype: 1-2 days

Costs:

• Claude Pro subscription: $20/month
• Development API usage: $10-50/month typically
• Node.js and VS Code: Free

When should you bring a developer into the picture?

For MVPs and quick demos, you can get surprisingly far without one. But there’s a turning point.

You likely need technical help when:

1. AI costs are climbing fast
   • Your bill exceeds $500/month in API costs
   • You need someone who can optimise how AI is integrated
2. Performance becomes an issue
   • Users report slow load times
   • The app crashes or hangs
   • You need caching, database optimisation
3. You need custom integrations
   • Connecting to payment processors
   • Syncing with existing corporate systems
   • Building custom APIs
4. You’re handling sensitive data at scale
   • User authentication beyond basic logins
   • Compliance requirements (HIPAA, GDPR)
   • Security audits
5. You want to reduce ongoing costs
   • Moving from managed services to self-hosted
   • Optimising API usage patterns
   • Reducing infrastructure spend

What kind of developer?

You don’t necessarily need a traditional software engineer. What matters more: someone who understands how AI systems behave in production and can balance reliability, efficiency, and user experience with financial realities.

Think: technical product person with strong engineering fundamentals.

Pro Tip

Treat AI like a junior developer.

AI naturally takes the shortest path to a goal. If your brief or requirements are vague, it will still produce working code, but often with shortcuts that are not production ready or scalable.

In layered workflows, where briefs flow into stories and then implementation, small mistakes early on quickly compound. AI will treat imperfect documentation as fact and build on top of it.

Invest more time upfront in clear requirements and early reviews. The tighter your inputs, the better your outputs, and the less technical debt you create downstream.

Summary

The Complete Workflow

Setup (one time):

1. Install VS Code
2. Add Claude Code extension
3. Install Node.js
4. Create project folder
5. Install BMAD framework

For each new project:

1. Start with Analyst agent → Create clear brief
2. Move to PM agent → Define requirements and stories
3. Consult Architect agent → Plan technical approach
4. Use Dev agent → Implement working code
5. Test, iterate, refine

Who This Works Best For

• Non-technical founders who need to validate ideas quickly
• Product managers who want to prototype without waiting for engineering resources
• Operators and designers who understand user needs but can’t code
• Early-stage teams exploring multiple directions before committing to one

Next Steps

1. Pick a simple project
2. Go through the Analyst phase
3. Generate your first working prototype
4. Notice what works and what doesn’t

The learning curve isn’t coding, it’s learning how to communicate clearly with AI. The better you get at structuring your thinking, the better your AI collaborator becomes.