Connect.AIHow models actually work, how to build with agents, and how to ship something that runs.
Scoping a problem, talking to a business, and writing down what you are actually going to do.
In the field with your partner business, start to finish.
Two weeks held back on purpose — Thanksgiving falls in the first of them.
Everyone open up your
Outlook email.

Your UConn address, and the temporary password from that email.

Replace the one you were issued. Eight characters minimum.
Photo, name, contact details. This is your directory entry.
Everyone in the program, with a direct line to each of them — email, phone, and a message button. Your own card is whatever you just filled in.

A standard connection between an AI assistant and a system — its data, its documents, what it can do. Ours is read-only.

Every session’s deck gets uploaded here as the semester runs — and the same material is accessible through the MCP.

Four movements. Open the one your session is in.

Every session in it, with a Ready badge once the deck is up.

Its own page, start to finish. Arrow keys, or swipe on a phone.
Open connect-ai.world in Safari, tap Share, then Add to Home Screen — it opens full-screen, like an app.

The square with the arrow, in Safari’s bottom bar.

Scroll the sheet if you don’t see it, then tap Add.
One tap to the decks, the Network and your messages.
How a model tokenizes what you give it and generates what comes back — and therefore when you can count on it, and when it will fail.
A model only knows what is put in front of it. Grounding puts the business’s own facts there — the company Palantir built.
When one call is not enough. Everything that actually works is three layers — the loop on top, and what holds it up.
What the model does on its own, between your ask and the answer.
What it holds while it works — and what it goes and looks up.
How it reaches the real world — the tools it is actually allowed to call.
You cannot ship what you cannot measure — and this system will not give the same answer twice. Two loops, and one calibrates the other.
Slow and expensive — and the thing every other eval gets calibrated against.
Cheap enough to run on every single change — once the human loop has calibrated it.
Enough of the underlying machinery to reason about a model instead of guessing at it.
What was learned once, and what is being computed every request.
Models inherit whatever is in the data — including its gaps.
Why something can be right on your examples and wrong in the field.
What the numbers actually measure, and what they quietly leave out.
The base layer every build runs on. Installed once on your machine (Winget on Windows).
Your logins for AI, the database, hosting, and planning — the four services you'll live in.
Where you actually write and ship — an AI-native IDE, an agentic CLI, and voice-to-code.
Write code yourself, or hand a task to an agent that writes and edits for you.
Where commands run — npm, git, and the Claude Code CLI.
/clear · /context · Plan mode · Skip permissions — how you steer the agent.
MCP servers, reusable Skills, and custom Agents extend what you can do.
Where your data lives — a real Postgres database, no server to manage.
Rules that decide who can see which rows — each business sees theirs, not everyone's.
Logins, passwords, and OAuth — sign-in handled for you.
SQL files that shape and version the schema as the build grows.
You move as a group of six, rotating through the partner businesses together.
You'll pitch your work and exchange ideas at cohort town halls.
A real business is on the other end of every one.
You represent UConn and Connect.AI to a business that trusts you.
The interface — buttons, forms, dashboards, and views people actually touch.
The bridge between your app and the outside world — data in, actions out.
Where data lives and logic runs — storage, auth, automations, and AI.
API keys & secrets. Never committed.
Project-level instructions for the AI.
Reusable skills your agents can call.
Database schema, queries & migrations.
Python automation & data scripts.
React components — your UI building blocks.
Markup and styling for the page.
READMEs and documentation.
Understand the problem and the goal.
Choose frontend, backend, APIs vs MCPs.
Design data flow, auth, integrations.
Code, test, iterate with Claude Code.
Ship to Netlify, hand off to the business.

Present your plan, exchange ideas, and pressure-test your build with the cohort.

Show progress, submit your live site, then start applying the skills to real business work.
Discovery interviews surface the real pain — not the one they lead with.
Trace symptoms back to a root cause before you build anything.
Know what's an AI-shaped problem — and, just as important, what isn't.
Plain language, not jargon. The business should understand every word.
Be explicit about scope, timeline, and what "done" actually means.
You're UConn and Connect.AI to this business — carry yourself like it.
Understand the problem, choose the stack, and design the flow before building.
Code, test, and iterate with Claude Code until it works for real.
Deploy, document, and hand it off so the business can run it alone.

Scope the work, frame the value, and use Plan mode to map the build before you commit.

Transition ownership — the accounts, the docs, and the training so the business runs it solo.
The partner businesses join. Your group rotates in to embed with a real Connecticut business — and from here, everything you build is for them.

Scope with the business and lock the plan.
Sprint the build; adjust as reality lands.
Test, document, and set it up in their accounts.
Business feedback, final presentation, and grade.