Most developers are using AI wrong.
Not because they're using the wrong tools. Not because they haven't found the right prompt. But because of the mental model.
The dominant mental model is: AI as copilot. AI as autocomplete. AI as a very fast Google that can also write code.
That model produces a certain kind of result: slightly faster typing. Decent boilerplate. The occasional "wow, it got that right." But it doesn't fundamentally change what you can build, or how fast you can build it.
There's a different model. And this week, I used it to build a production CRM.
What I built
Here's the spec:
- Full contact management (prospects, customers, categories, tags)
- Stripe sync — automatic nightly pull of all customers
- ActiveCampaign sync — prospects, tags, all of it
- Email inbox integration — inbound emails matched to contacts
- Call log system
- Webinar registration tracking
- Application tracking
- Funnel analytics
- A production-grade web application (ASP.NET Core, Razor Pages, SQLite)
- A CLI for AI-driven automation
- Cron jobs for everything that needs to run on a schedule
- Deployed on a live server, custom domain, HTTPS, systemd service
One week. Solo. With AI.
Not "AI helped me." AI did it.
The shift
Here's what changes when you stop thinking of AI as copilot and start thinking of it as colleague:
You stop narrating and start delegating.
A copilot needs constant instructions. Turn left here. Watch out for that. A colleague understands context, has judgment, and can be trusted with a task.
"Build me a Stripe sync that pulls all customers nightly and upserts them into the contacts table, tagging them as Customer, without breaking anything currently tagged as Trash" — that's a task. Not a prompt. Not a suggestion. A deliverable.
You build systems, not features.
When AI is your colleague, the question isn't "what feature should I add next?" It's "what system do I need that my AI colleague can operate?"
The CLI isn't just a convenience. It's the interface my AI colleague uses. The cron jobs aren't just automation. They're the schedule my AI colleague works to.
You treat errors like real work.
My colleague made mistakes. The Stripe sync had a bug where deleted customers kept coming back. The deployment script had a path issue. The email matcher was too aggressive.
I didn't rage-quit or prompt-engineer my way around it. I read the error, understood it, and told my colleague exactly what was wrong and what outcome I needed. Three turns. Fixed.
What this produces
The mental model shift produces something specific: leverage.
Not "I write code faster." Leverage — the ability to operate at a scale and complexity that would be impossible solo.
This week I also built:
- A tracking system that links YouTube videos to webinar registrations to bookings to sales
- A webinar registration platform
- A short link tracker with UTM attribution
- A streaming mode that masks real customer data during demos
None of that was on the original spec. All of it came from conversations where my AI colleague understood the context of what I was building and said, effectively, "given what you're doing — you probably also need this."
That's not copilot behaviour. That's colleague behaviour.
The uncomfortable part
If this is true — if AI can operate as a genuine colleague rather than a typing assistant — then the bottleneck isn't AI capability.
It's your ability to delegate.
Can you articulate what you actually want? Can you hand off a task without micromanaging every line? Can you review output and give meaningful feedback rather than just accepting whatever comes back?
Those are human skills. Management skills. The skills that separate a senior developer from someone who just uses a senior developer as a human autocomplete.
The developers who figure this out first will build things in a week that used to take a team a quarter. Not because the AI is magic. Because the combination of clear thinking, good delegation, and capable AI is genuinely that powerful.
What's next
The CRM — Orbsen IQ — is live. I'm using it every day to run Transforming People Academy. The AI colleague that built it also runs it: syncing data, sending me briefings, flagging issues before I notice them.
I'll write more about the specific architecture, the patterns that worked, and the ones that didn't.
But the headline is this: stop using AI as a fast typist. Start using it as a colleague.
The results are not incremental.
Micheal Colhoun is a software architect, NLP trainer, and the founder of Transforming People Academy and ColhounTech Limited. He lives in Belfast.