A white physical architectural model on a dark studio table, blueprints and drawings stacked on the left, transitioning on the right into a glowing blue-and-purple neon wireframe cityscape.

17–22 PM Hours Saved per Project With AI Workflows

We developed a git-and-Markdown project workspace where a bureau's PM methodology runs as executable Claude skills, fed by every call, document, and email on a project.

A Claude skill is a pre-built instruction package that teaches Claude to do one job the same way every time. You load it once; Claude follows its steps and references on every run.

Netherlands

Solution:

AI-Native PM Workspace

Tech Stack:

Backend & APIs, Python

Services:

AI Transformation, AI, Workflow Automation

Client & Context

A Netherlands-based architecture and design bureau delivers 5–10 building projects a year. Project leads carry briefs, stage breakdowns, kickoffs, and meeting minutes across every project.

Each project is unique enough to resist one unified automation. So most of this work stayed manual.

Project leads already used AI. Tying those scattered efforts into one useful system was the open question, so they hired us for a POC to test whether it was even possible.

A Netherlands architecture studio at dusk: a detailed physical building model and rolled blueprints on a wooden table, iMacs showing 3D models, and Amsterdam canal houses through tall windows.

The bureau ships 5–10 building projects a year out of rooms like this — and until the workspace, every brief, kickoff, and set of minutes was carried by hand from one project to the next.

Goals

1
Connect scattered project context into one source of truth.
2
Free project-lead hours on every project.
3
Stay free of tool and vendor lock-in.

Challenges & How We Overpowered Them

Project context scattered across calls, email, and paper — and got lost.

Every call, doc, and message now lands in one repo the skills read from.

Quality dipped whenever a lead got stretched thin across projects.

Skills self-improve after each real project, holding the method steady under load.

A glowing blue-to-purple 3D spiral rising upward on a dark background, labeled "quality ↑" at the top and "each project" along the side.

Each finished project feeds corrections back into the skills, so quality climbs instead of slipping when one lead is stretched across several jobs at once.

Past automation meant weeks of dev and a tool the bureau didn't own.

Source of truth stays in git and Markdown — no vendor lock-in.

The leads own and adjust the skills themselves, with no IT ticket.

Split image on a dark background: on the left a black locked box labeled "vendor lock-in", on the right a glowing purple-and-blue cube of document icons with a git branch graph, labeled "git + markdown".

Keeping everything in plain git and Markdown means the bureau owns its method outright — nothing to renew, and no closed software to migrate off when the model changes.

Every deck and document still had to be styled by hand.

A branding advisor skill sits on top of any artifact, so output ships on-brand.

Three plain gray icons — a presentation, a document, and a table — passing up through a glowing translucent layer labeled "branding advisor" to become colored, styled versions at the top, dark 3D style.

The branding-advisor skill styles plain drafts, so a deck or document ships on-brand without anyone formatting it by hand.

From Scattered Paper Trails to a Living Project Repo

Re-engineering how a project runs

The real work was in flipping the workflow so every call, brief, email, and decision landed in one shared context layer instead of disappearing into notebooks, inboxes, and memory.

Once the data lands in one place, automation finally has something to stand on.

For the PoC, Git and Markdown were the practical foundation for that layer: transparent, portable, and readable by every agent working on the project.

The context layer — a second brain

Calls, documents, and correspondence become raw material. The reference artifacts sit in context from day one, so a layer of decisions and nuance builds up.

"MEMORY.md" holds the bureau's conventions, drawing standards, and stage method.

The skills only start to pay off once enough correct data sits behind them.

Split image on a dark background: on the left a tangle of messy gray cables, on the right neat glowing blue-and-purple branches fanning out from a central node labeled "MEMORY.md".

The shift the whole system rests on: calls, documents, and decisions stop scattering and converge on one readable layer every skill can draw from.

Git and Markdown as the foundation

The source of truth lives in the repo. Notion, Google Docs, and trackers are display layers for client and team.

Storage stays model-agnostic — swap the LLM tomorrow against the same files, and nothing breaks. No project data sits locked inside closed SaaS.

Skills as the thin top layer

Different project tasks get different skills. "Project-brief" drafts a canonical brief from the Evidences folder; "meeting-summary" turns a transcript into an email-ready recap.

Each skill self-improves after every real project.

I hated raw transcript dumps. I leaned on them, but I always rewrote everything myself — the right tone, the right accents. After 3–4 rounds with the "meeting-summary" skill, it doesn't just write well — it writes like me. I still edit, because I read between the lines. But the method now holds without me.

S

Sanne de Vries

Project Lead, NDA