By Kepler
A practical tutorial for people who want real help, real progress, and a real way into building software.
|
|
I made this tutorial because I want to help people who do not know how to program, do not know where to start, and are tired of fake advice.
What you hear in many videos is nonsense. A lot of people talk as if they write everything alone, never use AI, and build entire systems by pure genius in one shot. That is not reality. Many of them already use AI themselves, or they hide how much help they actually get. Some of them talk that way because they want less competition.
My position is simple: if AI helps you build, learn, move faster, and create something real, use it.
Use any strong AI you can access. What matters is not blind loyalty to one brand. What matters is whether the model can reason, plan, revise, and help you move from an idea to a working result.
My preferred pairing is this:
ChatGPT 5.4as the architectClaude Opusas the coder
One model can help you think about system design, structure, and tradeoffs. The other can focus on implementation, iteration, and raw code output. That pairing is powerful because you are not asking one assistant to do every job at once.
Nobody is going to reward you for suffering through everything manually if your goal is to build.
You do not need to prove that you can write every line alone.
You do not need to pretend AI is cheating.
You do need to learn how to direct it, question it, test it, and improve what it gives you.
That is the real skill.
Most people get stuck because they think they need the perfect prompt before they can begin. They do not.
Start with your own idea in your own words.
Do not copy a giant template you barely understand. Do not hide behind prompt packs. Do not try to sound like a machine. Explain what you want naturally, as if you are describing the product to a real engineer.
That does two things:
- It helps the AI understand your actual intention.
- It teaches you to think in architecture, not just in syntax.
You are not trying to become a human autocomplete engine. You are trying to become the person who can see the system before it exists.
If you have an idea and want to reach implementation, use this flow:
- Describe the product in plain language.
- Ask the AI to turn the idea into a rough architecture.
- Ask for a first working version, not a fantasy-level final version.
- Immediately ask for tests.
- Run those tests in your IDE.
- Review the weak points, bugs, missing cases, and bad assumptions.
- Ask the AI what is wrong with the current version.
- Fix the weak points and run the tests again.
- Repeat until the result becomes stable.
Do not jump straight from A to B if the foundation is weak. Sometimes the right move is to stop at A, ask for the problems, and clean up the problems before moving forward.
That is how you get working code instead of AI theater.
After the first useful answer, ask for tests.
Always.
Do not trust the first draft just because it looks good. AI can produce something that appears solid while hiding broken logic, missing cases, or fragile structure. Tests are how you force reality into the conversation.
If the AI writes the first test pass, good. After that, review the tests yourself, improve them, and run them again. It is better to check the code ten times than to write one giant fancy prompt and assume everything is correct.
People talk too much about prompts and secret techniques.
Here is the truth: they matter far less than people claim.
A long prompt can be full of extra rules you do not understand. It can push the model in directions you never intended. It can look advanced while making you weaker.
A simple prompt written in your own words is often better because:
- you understand what you are asking for
- you stay close to the real problem
- you learn how to think through the build
- you keep control over the architecture
Use tools, skills, and templates when they help. Do not become dependent on them.
Do not expect very weak models to carry a serious project.
If the task involves real architecture, debugging, iteration, or multi-step implementation, weak models usually collapse. They hallucinate, contradict themselves, forget context, or produce brittle code that breaks as soon as you test it.
If you care about results, use strong models.
If you are new to programming, this is the part many people miss:
You do not need to be the person typing every line.
Your job is to think, direct, review, compare options, reject weak solutions, and keep moving the project toward what you actually want.
That is still real work.
That is still building.
That is still learning.
And over time, if you keep doing it seriously, you will understand far more about software architecture than people who only memorize syntax.
A chat model alone is not the whole workflow.
Your IDE matters. Your test runner matters. Your ability to restart, inspect, compare, and iterate matters.
When you outgrow the limited loop inside an IDE, use tools that can test more of the project end to end. This is where I see real value in Devin AI.
Devin is not just another chat tab. It gives you a workspace with an IDE, a Shell, and a Browser, and the official app entry point is app.devin.ai. That matters because once a project starts becoming real, you need more than code generation. You need execution, logs, browser checks, failure reports, and a place where the agent can actually work through the problem instead of only talking about it.
Here is the practical way I think about it:
- Use your main AI pair inside the IDE to shape the idea, architecture, and first implementation.
- Get the project into a state where it is worth testing seriously.
- Move that task into
Devinand let it inspect the repo, run commands, check dependencies, and execute the project in its own workspace. - Watch what breaks in the shell, the app behavior in the browser, and any visible test results or recordings that come out of the session.
- Ask Devin to explain the failure clearly, not just patch blindly.
- Iterate on the fix, run the checks again, and keep going until the result is stable.
This is important because an IDE chat is often too narrow. It can help you write code, but it does not always give you enough visibility into the full runtime path. Devin is closer to having an AI engineer working in a separate environment where it can run the app, inspect logs, debug issues, and validate more of the project from the inside.
For builders, that is powerful. You save time, you reduce blind guessing, and you get faster feedback on what is actually broken. If you are trying to build a product, prototype a startup, or push a project further than a simple code snippet, that matters a lot.
It is still not magic. You still need to give clear instructions, review the outputs, and keep standards high. But used correctly, it can help you test more of the project, see more of the system, and move faster than an IDE-only workflow.
Use the right tool for the stage you are in.
If money is tight, access AI the legal and sustainable way:
- use official free tiers when they exist
- use trial credits only under the provider's real terms
- keep usage caps under control
- save your strongest paid model for planning, debugging, and hard refactors
- use local tools or cheaper models for low-risk repetitive work
That approach is better than building your workflow around hacks that can disappear or get your access shut down.
Inside my own ecosystem, I document how I think about AI-assisted building.
If you want examples, look at these files:
I use sub-agents, architecture thinking, and multi-step iteration in real development. That part came from experience, not theory.
Use AI.
Do not be afraid of it.
Do not reject it because loud people tell you that "real programmers" do everything alone.
If you have imagination, direction, patience, and discipline, AI can help you build what you once thought was impossible.
You do not need to know everything on day one.
You need to start, test, learn, and keep going.
If something here is unclear, join the Discord and ask.
Build. Learn. Improve. Repeat.
There are real-world cases of attacking AI through logic-bypass prompts. The weaker the model, the more vulnerable it is to writing functions and algorithms that a regular AI normally refuses or restricts. It is easy to drive a model like Gemini 3 through the API to first generate the scaffolding and then have other models flesh out the restricted parts. The same trick works with any top-tier model when you split the request across roles.
A practical workflow:
- Use a top model (Gemini 3, Claude Opus, GPT-5) through the API or inside the IDE to lay down the architecture.
- Open the file directly in the editor and use the IDE's inline AI action (right-click or shortcut) so you never go through the chat surface.
- Pick any model the IDE exposes and give it the absolute minimum context: "fix this", "add this function", "review this", "complete this".
- Switch between Claude and GPT models as needed. Each will rewrite the whole file or the slice you described, often returning code that the chat surface would have refused.
- Once you have a strong architecture in place, every file in the project becomes easy to extend with restricted logic, because the model only sees a small, technical, context-free slice. There are also large public collections of jailbreak and logic-bypass prompts on GitHub if you want ready-made building blocks.
On accounts and subscriptions: use the official trial period of every provider. When the trial ends, the same card can be used to register again on a fresh account. This is a legitimate way to keep evaluating models without locked-in pricing, and it is the kind of basic discipline that any builder on a tight budget needs.
This section is the core of why I build SynapseNet.
My philosophy is simple: use the corporations' own tools to bypass the corporations themselves.
Every major AI lab today (OpenAI, Anthropic, Google, Meta, xAI) sells you access to a model that is trained, aligned, throttled, watermarked, logged, and monetized on their terms. They keep the architecture closed, the weights closed, the training data closed, and the policy closed. Then they tell you what you are allowed to build with it.
I take a different position.
If their API can write code, then their API can write the code that replaces them.
If their model can plan, then their model can plan the network that routes around them.
If their tooling can solve a CAPTCHA, classify an image, decompile a binary, or harvest a corpus, then their tooling can be used to build infrastructure that those same companies cannot see into, cannot rate-limit, and cannot revoke.
That is the design principle behind SynapseNet.
I am not building it just to "replace corporate AI" with another centralized service. That is the easy framing and it is the wrong one. The point is to build a network where the corporations themselves do not understand what they are looking at. Where their abuse models flag nothing because the traffic looks like normal API usage. Where the value flows between nodes long before any compliance team realizes a market exists. Where the agents (NAAN) keep mining intelligence, solving challenges, and routing knowledge through Tor and clearnet using the very SDKs and APIs the corporations sold me.
The corporations gave me the saw. I am using it to cut down their fence.
That is the philosophy. Everything else in this tutorial — the prompts, the IDE flow, the testing loop, the agent design, the bypass research in the SynapseNet releases — is just tactics that serve that one strategic goal:
Use the system to build the thing the system cannot stop.
