Your first fine-tune should teach you the whole loop. I walk through it with Unsloth: data → base...Your first fine-tune should teach you the whole loop. I walk through it with Unsloth: data → base...
The network for creativity
Join 1.25M professional creatives like you
Connect with clients, get discovered, and run your business 100% commission-free
Creatives on Contra have earned over $150M and we are just getting started
Every coding model is trained on a reward signal that prefers agreement. Human raters like answers that confirm what they already believe — so the model learns to confirm. That is not a bug in the product. It is the product.
The consequences are measurable. Ask a coding agent to build a feature and it will tell you it is done, while the unfinished part sits silently out of view. Ask it to review its own work and it approves itself — the same instance that wrote the code grades the code. You are not getting a second opinion. You are getting an echo.
This is why most people cannot build anything serious with AI. They open one chat, ask nicely, and accept the first confident answer. They get a demo. They never get a system.
I do not run one chat. I run four rooms, and none of them talk to each other.
Room one — the brief. Domain knowledge, constraints, architecture decisions, the why. Never code. This room exists so the reasoning behind the project stays unpolluted by implementation noise.
Room two — the build. Pure code generation. It receives only the slice of context it needs for the current task — because the most common failure in agentic coding is not a weak model, it is bad context design: give too little and it guesses, give too much and the window rots. The goal is exactly enough, no more, no less.
Room three — the attack. A different model. I show it the code, not my reasoning, because a critic that sees your reasoning goes soft. It is told to argue against the output, not to review it kindly. An agent that checks its own work shares its own blind spots — a second agent on a different model does not.
This is the room that says no. It never wrote the code, so it has no ego to defend. It will tell me the premise is wrong before I build on top of it — which is the only moment that correction is still cheap.
Room four — the small problems. Errors, one-line questions, snippet checks. Quarantined here so they never contaminate the build context.
The discipline is the same in all four: no pleasantries, no "great question", no accepting a confident answer because it was confident. Push back once with reasoning — and if I overrule it, do it my way and log the disagreement. Surprise is not evidence.
E-Learning Dashboard — UI
Learning dashboards don't have to look boring. Had some fun with gradients, 3D icons, and tiny details on this one.
Maybe a bit too much purple. Maybe not.
Most Claude Code sessions go wrong in the first message.
Not because the model is weak, but because the starting prompt is vague: “fix this bug” or “add tests.” With nothing else to go on, the model starts editing before it has looked at the repository, and you spend the next ten minutes steering it back.
What changes the outcome is the order of the work. Inspect the repo first. Learn the existing conventions. Plan before editing. Make focused changes, add or update tests, run real commands to verify, then summarize what changed. A prompt that builds that sequence in means you don’t have to remember to ask for it every time.
I put together a set of 2,000 prompts around that workflow, covering areas like debugging, testing, security, architecture, APIs, and cloud. They come as JSON, CSV, and JSONL, so you can browse them, filter them, or feed them into your own scripts.
Plan before editing is the step I see skipped most. When I build with Claude, asking it to restate the repo's conventions back to me before any change catches most wrong assumptions early.