how I built NORD

The simplest way to describe my work situation is: too many things, not enough me. I run Nordic Design Collective. I'm building several other ventures alongside it. The team is small, about ninety hours of combined weekly capacity across the whole business. Most of the operational work landed on me by default.

What was eating my time wasn't the actual building. It was the meta-work around the building. I'd spend hours writing out tickets and deliverables by hand, looking up documentation, searching for answers online, working on document standards and code standards and formatting. The repeatable tasks I do every day kept piling up, and each one was taking too long.

I started building NORD in December of 2025. The catalyst was simple. AI wasn't going away. The tools available at the time weren't doing what I needed. I was spinning my wheels writing more prompts and fixing mistakes and re-clarifying what I wanted, because the AI didn't understand what I was trying to do. I wanted something that would confine AI into doing exactly what it was supposed to do, with testable and repeatable results.

the accidental path to agents

I didn't start with agents. I didn't know agents existed when I started.

The first version was a scripting system. Bash and Python, routing tasks to different LLMs through the command line. I was trying to wire up something that could take a job and dispatch it to whatever model was best suited for that job. I'd write the routing logic, the prompts, the parsing, the error handling. Each task got more careful over time.

I arrived at the concept of agents by accident. I was building a version of them in scripts without knowing what they were called. When I learned that agents existed as a first-class construct in the platforms I was using, I started transitioning everything I'd learned from the scripting system into agents and skills.

The next realization changed the shape of the whole system. Context engineering mattered more than prompt engineering. The work moved from writing better instructions to building better context structure. Most of NORD now is context structure.

the company-as-agents vision

When I first sat down to design the agent system, I had a specific picture in mind. NORD would work like an actual company: executives at the top, department heads under them, and specialists inside each department doing the actual work.

The shape was clear. I interact with one agent, NordChief. NordChief reads my intent and delegates to the appropriate department head. The department head analyzes the task and delegates to a specialist on their team. The specialist does the work and reports back up. The department head reviews the result and returns it to NordChief. NordChief returns to me.

The first version of this didn't work. The platform I was building on, Claude Code, had a limitation: an agent couldn't spawn another agent that spawns another agent. The three-tier delegation chain broke at the second hop. I spent a while working around that. Eventually I figured out a routing pattern that respects the platform's constraints and preserves the department structure. The system I'm running now has that structure intact.

The modularity was deliberate from the start. The shape of NORD isn't specific to design or development. The same structure could work for accounting, logistics, finance, education, or any industry that has departments, specialists, and standards. Plug the right modules in and the system adapts.

why enforcement became the breakthrough

I used the alpha version of NORD for a few months before deciding to rebuild it.

What became apparent was that agents would interpret the same instructions in different ways. The standards were defined, but the standards weren't being enforced reliably. Every deviation cost me time, either in re-doing the work or in catching the drift after it shipped.

That's where I started building enforcement systems. Evaluation harnesses that test outputs against expected behavior. Automated checks that catch deviations before they get committed. Rules that are not just stated but verified. Custom skills that follow the exact same process every time. The principle behind all of it: any deviation from the defined system gets flagged before any time is wasted by an agent.

NORD v2 was born from that practical experience. The current version pushes enforcement deeper into the runtime. Hooks intercept operations before they happen, check them against the rules, and reject anything that violates. The agent can't drift because the hook stops the drift at the source.

what it does day-to-day

The morning briefing runs the first time I start the system each day. It pulls from Linear, GitHub commits across team projects, my calendars, team communication, and my journal and inbox notes. It also reads from NORD's own memory, which captures what was worked on, what the next steps are, what decisions were made, and where things were routed. The briefing assembles all of that into a single document that tells me what's on my plate, what's been moving, and what I need to be aware of.

Throughout the day, when I'm working on something, NordChief routes the work. This site is a recent example. NordChief understood the project at a high level and delegated. NordPlan generated the project brief from my input. NordDesign worked on the style guide and produced options for approval. NordFrontend scaffolded the site and built the pages. NordContent populated the writing. NordScribe recorded every decision into memory. I described what I wanted in plain language and the system figured out who handled each piece.

On Friday, before I close out the work week, the system reminds me to run the Friday audit. The output gets logged so the next Monday's briefing has fresh ground to read from.

Session handoffs are generated automatically. Each session picks up where the last left off.

The pattern across all of this: routine work that I used to do manually and forget half the time now happens reliably and gets logged.

what it's enabled

I can accomplish in one week what used to take me two or three months.

That sounds like a marketing claim. It isn't one. The compression isn't because I'm working harder. The meta-work has collapsed. Tickets that took hours now take minutes because NordPlan drafts them and I review. Documentation shows up alongside the work because NordScribe is logging as decisions land. Standards get enforced at the source instead of after, when fixing is expensive.

I'm running several simultaneous projects in different stages, keeping track of client work without dropping pieces, and staying organized in my personal life. I use NORD to improve NORD. When I notice a friction, I add a check, a skill, or a rule that addresses it. The system gets sharper with use.

what this kind of system is good for, and what it isn't

A system like NORD is good for the structural overhead around real work. Routing, enforcement, memory, briefings, audits, standards. The repeatable layer that no operator wants to do by hand but every operator pays a tax for skipping.

It isn't a replacement for the operator's judgment. NORD doesn't decide what I build, who I hire, what I write about. Those decisions stay with me. NORD handles execution around decisions I've already made.

If you're running solo or near-solo and the meta-work is what's bleeding your week, this kind of system is worth building. If you're hoping for something that thinks for you, you'll be disappointed by this and by every other agent system on the market today.