CJ Zafir Profile picture
Dec 28, 2024 16 tweets 6 min read Read on X
Code your Dream Project with AI

Use tools like:
- Cursor to code complex projects.
- bolt, lovable to code websites, micro SaaS.
- v0 lovable to code frontend screens

Step by Step Guide to code your first software with AI:
(Bookmark this for future use) Image
First of all, you need to understand how AI coding works.

We have amazing LLM models like Claude Sonnet 3.5 that can write high quality code (based on instructions) in any famous coding language.

It can help you build:
- web apps
- mobile apps
- browser extentions
- downloadable software
- landing pages or websites

You name a use case, AI models are now able to code that.
We also have amazing AI coding tools that help us code, debug and deploy your project.

Tools like:
- cursor AI (famous AI code IDE)
- bolt .new (simple IDE on the web)
- lovable (similar to bolt, getting better)
And more.

Each AI coding tool has its own superpowers.

Some can code softwares really good, some code websites or landing pages.
So we need to pick the best AI coding tool for your use case and use Sonnet 3.5 model to get our first project done.

AI coding = Detailed Documentation + Step by Step Prompting.

Let me explain this:
Claude Sonnet 3.5 and other coding models works great when they are given proper plan.

A detailed end to end blueprint of the project.

Whats the project is all about? What Tech Stack are we using? Whats the app flow? Design instructions? Backend Structure etc

The point is: Don't let AI models assume things! Give them proper plan to follow.Image
Now let me tell you how to work with 4 major tools.
- Cursor/Windsurf
- Bolt .new
- Lovable

We choose the AI coding tool and we provide them Documentation around our project.

Lets talk about what Documentation you need to create?
1. Project Requirements Doc (PRD)
It provides the overview of the project. It covers all major parts of your project in a concise way
- Introduction
- Tech stack
- Frontend
- Backend
etc Image
2. App flow Document: This document provides a complete rundown of the project page-by-page like:

"User starts their journey from x landing page and sign up with Google and land on dashboard. On dashboard there are y, z, a, b sections......"

This is also a very important document for AI model to map out the application in its context.Image
3. Tech Stack document: This document covers all technical information about what:
- What tech stack we are using?
- What packages, dependencies to install?
- What APIs we are using? Their docs

Basically it provides AI models the framework to work with, for that project.

These 3 documents are CORE documents that provides 60% of context about your project.Image
Then you should alse create:
- Frontend Guidelines
- Backend Structure
- File Structure Doc

These 3 docs are specific for their fuction and it provides function specific details. Image
You can use GPT o1 model to get these documents done.

This is a MUST step for AI coding practice. You skip and and you regret it when you get tons of errors and hallucinations from AI models.

I automated this process for you with CodeGuide.

Create all your Project Development Documentation with CodeGuide.Image
But what would I do after I download all documents?

Let me tell you what docs you would need for what tools.

If you work with Cursor, you need to create a folder in root directory with "instructions" or "Documentation" name.

Then attach all documents you've created with CodeGuide.

Then open a new Composer terminal and ask: What do you know about my project? And tag the folder.

Cursor will go tead through all docs and provide you the overview.

Perfect now you can start asking it Step by Step, what to build.Image
If you work with Bolt or Lovable.

You need Project Requirements Document + app flow document.

Add PRD first, ask it: before you start coding, tell me what do you understand about my project?

And then once you get the response you attach App flow document. This will provide end to end flow of your project.

Then you can start with your project setup, and coding the components step by step.Image
Bottomline:

AI models can code, but they hallucinate, make errors if we don't provide project context.

Project Development Documentation solves this issue. (with CodeGuide)

AI tools are use case specific. Pick your use case and then use the best AI coding tool for that purpose.

For simple projects use bolt, lovable, replit and v0

For complex applications use Cursor or Windsurf
For simple projects attach PRD + app flow doc to begin with and then attach relevant documents on the go.

Like when you need to build backend, attach backend structure doc.

This approach don't put stress on thess tools and provide the right context at right time.

For Cursor/Windsurf create a folder and attach all docs in the beginning.
Sign up with today.

I have 30% off for Yearly plan for limited time.

If you need a discount on monthly plan, DM me I have few coupons left.

But guys, get strated. Learn AI code. It'll change your life for good.

Peace
CJCodeGuide.dev

• • •

Missing some Tweet in this thread? You can try to force a refresh
 

Keep Current with CJ Zafir

CJ Zafir Profile picture

Stay in touch and get notified when new unrolls are available from this author!

Read all threads

This Thread may be Removed Anytime!

PDF

Twitter may remove this content at anytime! Save it as PDF for later use!

Try unrolling a thread yourself!

how to unroll video
  1. Follow @ThreadReaderApp to mention us!

  2. From a Twitter thread mention us with a keyword "unroll"
@threadreaderapp unroll

Practice here first or read more on our help page!

More from @cjzafir

Aug 16
Introducing Codespace

A virtual computer that runs custom Claude Code on server.

It is using 2 models: Kimi K2 + Claude Sonnet 4 in a sync.

I achieved same code quality with 2x better reasoning and 53% less model cost.

Access it today @CodeGuidedev
(500 credits for everyone)
We fixed some core issues:
1. It works with new and existing codebases and it won’t touch your existing code.

It can scan large codebases, 10M tokens (250,000 lines of code) and remember all core details.

Just attach your GitHub Account and select the repo you want to work on. Image
Image
2. It works autonomously (you don’t need to hit accept all) everytime.

It generates 7 docs to build a solid knowledge base to refer and create detailed tasks/sub-tasks list on autopilot.

Resulting in 88% less hallucinations and better code structure. Image
Read 8 tweets
Aug 14
Every AI startup is focused on "Build me an ........... app" (New projects)

But what about millions of existing codebases on GitHub with billions of lines of code?

To focus on existing codebases, I built a coding environment: Codespace.

(Explained below)
Simple Steps:
1. Connect your GitHub Account
2. Open Codespace and select the repo you want to work on. (AI agent will make an isolated environment for every request)
3. Let AI agent Analyze, generate docs and tasks list
4. analyze the kanban board to track tasks
5. Go have coffee and wait for the agent to email you when done.
I built a Claude Code wrapper that:
- runs on cloud (access it with phone, or laptop)
- can analyze upto 10M token size codebases
- has better visual UI & flow
- generate docs (knowledge base)
- tasks/sub-task list (2x better than claude)
- notifies me when its done via email
Read 5 tweets
Jun 27
I built "Clade Tasks" to make Claude Code 10x better and 2x cheaper.

I integrated 3 engines in 1 flow:

1. Claude Code (best agentic coding interface)
2. CodeGuide (to provide deep context to AI)
3. Taskmaster (to create detailed implementation plan)

Here's how it works: ↓
Claude Code is the most powerful AI coding tool right now.

Yes better than Cursor/windsurf.

But Claude 4 (the underlying model) can spit out unnecessary files/code and burn tokens.

Also it's plan mode is good but I found a better alternative: ↓
1. Plan before code

"Build me x, y, z." type prompts don't work because of no technical context.

So turn your idea into a set of well structured docs:
- PRD
- Tech stack doc.
- App flow doc
- UI guidelines
- backend structure
etc

@CodeGuidedev write these docs in only 3 steps Image
Read 7 tweets
Jun 15
The most important document in AI coding: PRD
(Project Requirements Document)

It serves like a blueprint & explains:
- project's overview
- tech stack
- user flow
- core features
- ui details
- backend schema
- security guidelines
- regulations

Here's how you can create PRDs:
Before you create a PRD, brainstorm with ChatGPT voice.

This step will help you finalize what features you want in your version 1.

In the end ask ChatGPT: "now add all approved features in one document and create a detailed draft)

Now it's time to create a PRD.
I use @CodeGuidedev to create all my coding docs including PRD

It uses 03 + 04-mini + Sonnet 4 model to create extensive set of docs

Flow is simple

Step 1: Open "New Project" and paste the feature draft in the input field

Step 2: Now select AI tools & AI models you'll use
Read 8 tweets
Apr 18
What are AI Agents?

OpenAI just published 30-page guide on AI agents.

I explained the guide in 10 points. Bookmark this: Image
1. Agents ≠ basic workflows

A normal “workflow” just runs a fixed list of steps with an LLM; it doesn’t think for itself.

On the other hand, Agents are systems that independently accomplish tasks on your behalf.

Workflows are linear. Agents are dynamic & autonomous. Image
2. Use agents for the complex jobs

Agents handle changing rules, tricky choices, and unstructured data better than any fixed script.

Pick jobs that need judgment, change a lot, or rely on messy text, images, or PDFs. Image
Read 12 tweets
Apr 10
I tested Gemini Pro 2.5 as my main coding model for 40+ hours.

Here're 2 documents that are working brilliantly well with Gemini.

"App flow document + App flowchart."

This made my Cursor workflow 10x better. Here's why it is working: ↓
Gemini Pro 2.5 has a 1 million token context window.

In simple terms it can scan upto 100,000 lines of code instantly to understand full codebase.

Claude & GPT models has 200k context window and that's why they struggle with large codebases.
But large context window doesn't mean Gemini doesn't hallucinate or assume things.

That issue is still there but I'm able to fix hallucinations by 95% in Gemini with my 'Context Boundary' technique.

You need to provide context with coding docs:
- PRD
- App flow doc
- Tech stack doc
etc

But here's how 2 docs are working really good with Gemini.Image
Read 7 tweets

Did Thread Reader help you today?

Support us! We are indie developers!


This site is made by just two indie developers on a laptop doing marketing, support and development! Read more about the story.

Become a Premium Member ($3/month or $30/year) and get exclusive features!

Become Premium

Don't want to be a Premium member but still want to support us?

Make a small donation by buying us coffee ($5) or help with server cost ($10)

Donate via Paypal

Or Donate anonymously using crypto!

Ethereum

0xfe58350B80634f60Fa6Dc149a72b4DFbc17D341E copy

Bitcoin

3ATGMxNzCUFzxpMCHL5sWSt4DVtS8UqXpi copy

Thank you for your support!

Follow Us!

:(