The Signal Method: Where Strategy Meets Code

TLDR: Strategy that lives in slides and Notion is invisible to the developers and AI tools doing the actual work. The Signal Method puts strategy, decisions, and knowledge directly in the repo so AI can reason over it and execution is traceable from intent to commit. Your framework is either in Git or it’s fiction.

Start free → app.intelig.ai

If Your Framework Isn’t in Git, It’s Fiction

There are plenty of frameworks for building SaaS. Vision frameworks. Product frameworks. Agile frameworks. AI frameworks.

Most of them are fine. They just fail at the most important moment: execution.

Because execution doesn’t happen in decks. It doesn’t happen in Notion. It doesn’t happen in Jira.

Execution happens in one place: the repo.

And if your framework doesn’t live there, it might as well not exist.

The Real Problem Isn’t Frameworks — It’s Gravity

Frameworks don’t fail because they’re wrong. They fail because they float.

Vision lives in a Google Doc
Roadmaps live in slides
Meetings produce decisions that nobody writes down
Action items live in someone’s head
Developers live in Git

That gap — between intent and code — is where execution dies.

Every quarter, the same ritual plays out: leadership declares priorities. Product creates tickets. Developers code against tickets with zero context about why this work matters. Three months later, the CTO asks “did we ship the platform migration?” and nobody can give a straight answer.

Not because the team didn’t work hard. Because the connection between what was declared and what was executed was never tracked.

And in the AI era, that gap is fatal. AI doesn’t execute vibes. AI executes context. If your strategy isn’t in a place AI can read it, your AI tools are flying blind.

What Is the Signal Method?

The Signal Method is simple: put your strategy, knowledge, and decisions in the repository — where developers already work and where AI can reason over it.

Everything becomes a signal:

Strategy signals — Vision, themes, initiatives, roadmaps. What you’ve declared you’re building and why.
Knowledge signals — Meeting decisions, architecture reviews, research, action items. The context behind the work.
Engineering signals — Standards, patterns, principles. How you’ve agreed to build.
Feature signals — PRDs, decision logs, work item breakdowns. The living documentation of every feature.

Signals flow down from leadership into the repo. Developers pick them up and execute with full context. AI reads them and reasons with real organizational knowledge.

Signals accumulate. Signals compound. Signals execute.

How It Actually Works

Step 1: Strategy Goes Into the Repo

Your Q1 initiatives don’t stay in a slide deck. They land in product/strategy/initiatives.md with:

Clear goals and success metrics
Ownership (which team, which lead)
What’s in scope and what’s explicitly not
How you’ll measure success

A developer working on any task can trace it back to the initiative it serves. “Why am I building this?” is always answered.

Step 2: Knowledge Flows In

Tuesday’s architecture review. Friday’s sprint retro. The customer call where you learned your onboarding is broken.

In the Signal Method, those aren’t throwaways. They produce artifacts:

Decisions with rationale — not just “we chose Kafka” but why we chose Kafka, what we considered, and what we rejected
Action items that are tracked, not forgotten
Context that compounds — a decision made in January informs a trade-off in June, but only if it’s captured

This is organizational memory. Most companies don’t have it. They rely on tribal knowledge that walks out the door when someone quits.

Step 3: Developers Build with AI — and AI Has the Full Picture

Here’s the difference:

Without the Signal Method:

Jira ticket: “Extract payments service from monolith.” No context. No rationale. No link to strategy. The developer and their AI tools guess at scope, make assumptions about architecture, and build something that may or may not align with what leadership intended.

With the Signal Method:

The developer opens the repo in Claude Code (or Cursor, or any AI-powered editor). They say: “Start extracting the payments module.” AI reads the initiative, the architecture decision (strangler fig, payments first), the meeting notes where the team discussed risk, and the success metrics. It builds with the full picture — not just code-level context, but organizational context. Why this work exists. How the team decided to approach it. What success looks like.

Same developer. Same AI. Completely different output.

This is the shift: AI stops being a code autocompleter and starts being a strategy-aware execution partner. It reads CLAUDE.md — a file that summarizes your current organizational state — and instantly knows your active initiatives, recent decisions, open action items, and engineering standards.

The more signals in your repo, the smarter AI gets. It compounds.

Step 4: Measure What Shipped — Anytime, Not Just End of Quarter

The CTO doesn’t wait three months to find out if priorities shipped. At any point, they can ask: “How’s the monolith initiative going?”

The answer isn’t a PM’s opinion or a status update meeting. It’s traceable evidence: commits linked to the initiative, decisions documented with rationale, progress measured against declared goals. What shipped, what’s in progress, what stalled, and why.

The Signal Flow, End to End

Let’s trace a real initiative from declaration to delivery:

1. CTO declares initiative

“Ship multi-currency support for APAC expansion. Target: Q1. Owner: Payments team.”

This lands in product/strategy/initiatives.md. Clear scope. Measurable goal. Assigned ownership.

2. Architecture review happens

Team decides: add currency as a first-class entity in the ledger, not a conversion layer on top. Decision rationale documented. The alternative (conversion layer) was rejected because it creates rounding errors at scale.

Decision lands in sources/meetings/ with full rationale.

3. Feature gets specced

PRD written in product/features/multi-currency/prd.md. Non-goals explicitly stated: no crypto, no real-time forex. Work items broken into backend (ledger changes, API endpoints) and frontend (currency selector, display formatting).

4. Developers build

Every commit references the initiative. Every PR links to the work item. When a developer hits an ambiguity (“should we support partial currency conversion?”), the answer is in the PRD’s non-goals section. No Slack thread. No waiting for a PM. The signal is already there.

5. Quarter ends

CTO asks: “Did multi-currency ship?”

The answer isn’t a PM’s opinion. It’s traceable evidence:

47 commits linked to the initiative
12 PRs merged across 3 repos
Architecture decision documented with rationale
Success metrics tracked against goals

That’s the Signal Method. Signal Over Noise. Intent to Execution. Execution to Evidence.

What InteliG Does With This

The Signal Method works standalone. Fork the open-source repo, maintain it manually, and your team has better context than 90% of engineering orgs.

But maintaining signals manually takes discipline. People forget. Meetings don’t get transcribed. CLAUDE.md goes stale. Commits don’t get linked to initiatives.

InteliG automates the entire signal pipeline.

Strategy Sync

Define your vision, themes, initiatives, and roadmap in InteliG. It pushes them directly to your Signal Method repo via PR. Strategy stays current without anyone manually editing markdown.

Meeting Ingestion

Connect your meetings. InteliG extracts decisions, action items, and context automatically. They land in sources/meetings/ as structured artifacts. No transcription. No manual summarization. Decisions stop vanishing.

Initiative-to-Code Linking

This is the part nobody else does.

InteliG’s AI engine — Cognis — analyzes every commit your team pushes. Not just the diff. The intent. It classifies each commit against your declared initiatives automatically.

“Break Up the Monolith” had 47 commits this quarter. 80% were from Core Platform team. 3 were misclassified bug fixes. One developer contributed 60% of the effort — bus factor risk.

You didn’t tag anything. You didn’t label anything. Cognis read the code and connected it to your strategy.

Execution Intelligence

At any point, you can ask: “How is Q1 going?”

Not a dashboard with 47 vanity metrics. A direct answer:

Multi-currency: 85% of planned work shipped. On track.
Monolith decomposition: 40% shipped. Payments module done. Ledger extraction stalled — only 2 people know that code.
Merchant portal rebuild: 20% shipped. Behind. Frontend team pulled into incident response for 3 weeks.

Evidence-backed. Traceable to commits. Not opinions.

Standards Enforcement

Your engineering standards live in engineering/standards/. InteliG scores commits against them. When code drifts from your declared patterns — missing tests, wrong architectural boundaries, skipped error handling — it flags it before it compounds.

Why This Matters Now

The companies that win the next decade will be the ones where AI has real organizational context — not just code, but why the code exists, what it’s supposed to accomplish, and how it connects to strategy.

Most companies aren’t there. Their AI tools see code in a vacuum. Their strategy is in slides AI can’t read. Their decisions are in Slack threads that vanish.

The Signal Method closes that gap. It’s free, it’s open source, and it works today.

InteliG makes it automatic.

Get Started

Use the Signal Method (free, MIT licensed): Fork the repo on GitHub

Automate it with InteliG: intelig.ai

The Signal Method is an open-source methodology by InteliG. Signal Over Noise. Truth Over Comfort. Intent to Outcome.