Contiamo x Telekom

Symbiotic
Engineering

Daniel Mahlow  /  19 February 2026

Quick context

Data & AI consultancy.
Berlin. 12 years.

~30 people.

All senior.

DAX real estate · telecoms · energy · logistics

So what is

Symbiotic
Engineering?

AI does not replace engineers.

Engineer

judgment, context, taste

+

AI

speed, breadth, tirelessness

More than the sum.

The floor got lower.

The ceiling got higher.

Let me show you

How this looks
in practice.

Part II

The Shift

Two years ago...

auth.ts utils.ts
14async function validateToken(token: string) {
15 const decoded = jwt.verify(token, secret);
16 if (!decoded) {
17 throw new Error("Invalid token");
18 }
19 // TODO: check token expiry
20 // TODO: handle refresh tokens
21 // TODO: add role-based access
22 return decoded;
23}
24
25

Write every line. Google every question. Hope you remembered the edge cases.

Today.

Terminal - claude
$ claude "refactor the auth middleware to use JWT tokens" Reading src/middleware/auth.ts... Reading src/types/user.ts... Reading src/routes/login.ts... Reading src/config/auth.ts... Plan: Update auth middleware to validate JWT tokens instead of session cookies. Changes needed in 3 files: - src/middleware/auth.ts token validation, expiry, refresh - src/routes/login.ts token generation on login - src/config/auth.ts JWT secret, expiry config Shall I proceed?

Describe the intent. The agent reads, plans, executes.

The word that matters:

Agentic

The distinction

Agentic vs. Autocomplete

Autocomplete

handlers.ts
7export async function getUser(id: string) {
8 const user = await db.query(`SELECT * FROM users WHERE id = $1`, [id]);
9 if (!user.rows.length) {Tab to accept
10 throw new NotFoundError("User not found");
11 }
12 return user.rows[0];
13}

You drive. AI suggests the next few lines.

Agentic

Terminal - claude
$ claude "add proper error handling to all API routes" Scanning project structure... Found 14 route handlers across 6 files Reading src/middleware/errorHandler.ts Reading src/types/errors.ts Plan: 1. Create typed error classes (NotFound, Validation, Auth) 2. Update 14 handlers to use typed errors 3. Add error middleware to catch and format responses 4. Add tests for error scenarios Editing src/types/errors.ts done Editing src/routes/users.ts done Editing src/routes/auth.ts done Editing src/routes/projects.ts done ... Running npm test 47 passed

You describe. AI explores, plans, executes, verifies.

Autocomplete

You drive, AI suggests

One file at a time

Line-level assistance

Copilot Cursor inline

Agentic

You describe, AI executes

Entire codebase in context

Multi-file coordination

Claude Code Codex CLI

Both have their place.

The productivity leap
is in the agent.

Part III

The Floor & The Ceiling

The floor

↓

got lower

Anyone can get something working.
Prototypes in hours, not days.
"Just make it work" is trivially easy now.

The ceiling

↑

got higher

Blindly trusting AI output
creates technical debt
at machine speed.

The gap between

"it works"  and  "it's good"

is where the real skill lives.

Part IV

The Workflow

The Pipeline

RESEARCH → PLAN → IMPLEMENT → REVIEW → FIX → SHIP

Core principle:

Never just one model's opinion
on anything important.

Step 1

Research & Plan

Catch wrong assumptions before any code is written.

Terminal - claude
$ claude "plan the migration from REST to GraphQL for the user service" Reading src/routes/users.ts Reading src/models/user.ts Reading src/middleware/auth.ts Reading tests/users.test.ts Reading package.json Plan: 1. Add graphql + apollo-server dependencies 2. Create schema types mirroring existing User model 3. Create resolvers wrapping existing service layer 4. Mount GraphQL endpoint alongside REST (parallel run) 5. Migrate tests to use GraphQL queries 6. Deprecate REST routes after validation # No code written yet. Just a plan to review.

AI reads. AI plans. Engineer decides.

Step 2

Multi-model Validation

Claude Gemini GPT

Different training. Different blind spots.

Terminal - claude (subagent delegation)
$ claude "ask gemini to review this migration plan" Spawning gemini-delegator agent... Gemini's assessment: - Migration order looks correct - Consider adding rollback step for users table - The index creation should happen AFTER data migration (currently scheduled before - will lock table) > 2 of 3 points align with Claude's plan > 1 new issue found: index timing

Claude spawns Gemini as a background task. Models cross-check each other.

Step 3

Implement

Small, focused chunks. Not one massive generation.
Implement, test, verify. Each piece works before the next.
Continuous dialogue. Not "generate and pray."

Terminal - claude
$ claude "implement step 1: schema types" Creating src/graphql/schema/user.graphql done Creating src/graphql/types/user.ts done Running npm run typecheck pass $ claude "now step 2: resolvers, reuse the existing service layer" Creating src/graphql/resolvers/user.ts done Running npm test 12 passed $ claude "step 3: mount endpoint, add integration tests" Editing src/server.ts done Creating tests/graphql/user.test.ts done Running npm test 24 passed

Step by step. Test after each step. Human steers.

Step 4

Triple Review

Three models review every PR. Independently. In parallel.

Terminal - triple-review
Running triple review on PR #247... Claude ████████████ done Gemini ████████████ done GPT-5 ████████████ done Findings: ┌──────────────┬────────┬────────┬───────┐ │ Issue │ Claude │ Gemini │ GPT-5 │ ├──────────────┼────────┼────────┼───────┤ │ SQL inject │ ● │ ● │ ● │ ← fix │ N+1 query │ ● │ ● │ │ ← investigate │ Dead code │ │ ● │ │ ← low priority └──────────────┴────────┴────────┴───────┘ 1 critical 1 warning 1 info
3/3

agree

→
Fix it.
2/3

agree

→
Investigate.
1/3

flags it

→
Noise or edge case.
Step 5

Fix & Iterate

Terminal - claude
$ claude "fix the SQL injection issue flagged in review" Reading src/graphql/resolvers/user.ts Found: raw string interpolation in query at line 42 Editing src/graphql/resolvers/user.ts done Adding tests/security/injection.test.ts done Running npm test 26 passed # Review feedback becomes implementation input.
The honest part

Where automation
hits limits

Full Automation

Virtual dev teams

Autonomous execution

No human in the loop

Looks impressive. Output plateaus fast.

Structured Process

Human guides direction

AI executes steps

Continuous feedback loops

Less flashy. Consistently better output.

"There's a certain urge to fully automate as much as possible. You quickly hit limits. We set up virtual development teams. At the end of the day, the output is not much better than when you steer it through a structured process."

The human in the loop is the
most important component.

Part V

Skills

Encoding tribal knowledge

A skill is a markdown file

Instructions, context, decision trees

Cluster names, credential locations, schemas

Edge cases, workarounds

"The thing that always breaks"

Terminal
$ ls ~/.claude/skills/ analytics/ deploy/ process-document/ feedback-reprocess/ health-monitor/ pr-review/ triple-review/ meeting-processor/ $ ls .claude/skills/ pipeline-test/ staging-deploy/ schema-migrate/
Personal: ~/.claude/skills/ Project: .claude/skills/

The rule:

Done it 3+ times?

Make it a skill.

Before

Production data analysis ( manual )

1. Remember which Kubernetes cluster

2. Switch context, set namespace

3. Find the right pod name

4. Start port-forward to database

5. Remember credentials

6. Remember schema (tables, columns, relationships)

7. Write SQL, run query, format results

8. Clean up port-forward

After
Terminal - claude
$ claude "show me extraction accuracy by category for last week" Connecting to production cluster... Port-forwarding to analytics database... Extraction Accuracy (Feb 10-17): +-----------------------+----------+---------+ | Category | Accuracy | Volume | +-----------------------+----------+---------+ | Invoices | 94.2% | 1,247 | | Contracts | 91.8% | 834 | | Maintenance requests | 88.5% | 2,103 | | Insurance claims | 85.1% | 456 | +-----------------------+----------+---------+ Cleaning up port-forward... done

One sentence. The skill handles the other eight steps.

Document processing pipeline

Before

1. Clone repo, install deps

2. Which pipeline? (there are several)

3. Find the right entry point

4. Set up metadata

5. Run with correct args

6. Parse and interpret output

After

$ claude "Process this PDF
  through the insurance
  pipeline"

The skill encodes
tribal knowledge

The ceremony disappears.
The intent remains.

Write once, everyone benefits

Shared via a team repository - a skill marketplace

New team members get accumulated knowledge instantly

Onboarding: weeks to days for common workflows

Knowledge doesn't leave when a person leaves

Beyond Code

It doesn't stop
at code.

Meetings

Terminal - claude
$ claude "what action items came out of last week's client meetings?" Searching meetings/2026-02-10/ through meetings/2026-02-14/... Found 4 meeting summaries Action Items (Week of Feb 10): Daniel: - Send updated API spec to partner team - Review staging deployment before Friday Kira: - Follow up on insurance pipeline accuracy - Schedule workshop with operations team Philipp: - Prepare training materials for March session

Transcripts become structured summaries. Action items extracted, attributed, searchable.

The full loop

Planning

Architecture reviewed by multiple models.
AI as sparring partner for process design.
Docs stay current because updating is trivial.

PR Workflow

Implement with AI.
Multi-model review.
Fix, human review, ship.

Knowledge

Meeting summaries queryable.
Decisions traceable.
Context never lost.

Every step has AI support. Every step has human oversight.

The Generalist's Moment

Every engineer,
amplified.

Without AI

Frontend specialist

Backend specialist

Infra specialist

Data specialist

Deep but narrow.
Coordination overhead between silos.

With AI

Same people, broader reach

Each engineer covers more ground

Specialists go even deeper

Boundaries between domains blur

Not fewer people.
Each person, more capable.

"The engineers who are curious, who pick things up quickly, who see connections between domains - AI amplifies those strengths enormously."

You own
the output.

"I'm not sure, but
Claude said..."

No.

Verify. Challenge. Understand.

Ask the AI why it chose that approach

Get a second opinion from another model

Read the actual docs or source code

Use the tools to verify, not just generate

If you can't explain it, don't ship it.

Symbiotic Engineering

1. Use AI as a partner, not a replacement

2. Never trust a single opinion

3. Encode your knowledge as skills

4. Process matters more than tools

5. Own your output

Thank you.

Daniel Mahlow

Contiamo

daniel@contiamo.com

Questions?