🚀 From Idea to Autonomous System: How Jenny Runs Learn Teach Master with Claude Code, MCP, and GitLab Pipelines

🚀 From Idea to Autonomous System: How Jenny Runs Learn Teach Master with Claude Code, MCP, and GitLab Pipelines

Intro

What if your platform didn’t just publish content…

What if it decided what to create, built it, and deployed it—on its own?

That’s not theory anymore.

With the right architecture, you can move from “using AI tools” to building an intent-driven system that continuously senses, decides, creates, and improves.

This is exactly what Jenny does.

🧠 What Is Jenny?

Jenny is not just an AI assistant.

She is an agentic platform orchestrator—a system that:

• Discovers what matters

• Decides what to create

• Generates content

• Requests approval

• Publishes automatically

• Learns from results

Powered by:

• Claude Code → reasoning + generation

• Model Context Protocol (MCP) → integrations and tools

• GitLab Pipelines → execution engine

• Python → orchestration logic

👉 Jenny isn’t a feature. She’s a system pattern.

🏗️ The Architecture (Intent-Driven by Design)

At its core, Jenny follows a layered architecture grounded in intent-driven engineering.

🔹 1. Intent Layer (Control Plane)

Everything starts with intent.

These are structured files (Markdown or YAML) that define:

• The goal (e.g., “Find trending AI topic”)

• Constraints (tone, structure, audience)

• Outputs (Wix article, video, social content)

👉 This is where humans stay in control.

🔹 2. Jenny Orchestrator (Python Agent)

This is the brain.

Jenny:

• Calls Claude for reasoning

• Routes tasks to tools via MCP

• Controls flow between steps

• Applies decision logic

Example:

class JennyAgent:

    def run_cycle():

        topic = discover()

        article = generate(topic)

        if approve(article):

            publish(article)

🔹 3. Claude Code (Cognitive Engine)

Using Claude Code, Jenny can:

• Analyze trends

• Generate structured articles

• Create scripts and summaries

• Maintain consistent tone and format

👉 Claude is the thinker

👉 Jenny is the operator

🔹 4. MCP Servers (Execution Layer)

MCP turns Jenny into a real system.

Examples:

• Search MCP → discover trends

• Wix MCP → publish articles

• YouTube MCP → embed videos

• GitHub MCP → store and version content

👉 MCP = Jenny’s hands in the real world

🔹 5. GitLab Pipelines (Execution Engine)

This replaces Jenkins entirely.

Using GitLab:

• Pipelines orchestrate Jenny’s lifecycle

• Scheduled jobs trigger daily runs

• Manual stages provide approval gates

• Everything is version-controlled

👉 GitLab becomes the heartbeat of automation

🔁 The Jenny Lifecycle (End-to-End Flow)

This is where it all comes together.

Step 1: Discover

Jenny asks:

“What should we create next?”

Using MCP:

• Web search

• Competitive analysis

• Content gap detection

Step 2: Decide

Claude evaluates:

• Relevance

• Strategic alignment

• Coverage gaps

Outputs a structured decision:

• Topic

• Reason

• Confidence score

Step 3: Create

Claude generates:

• Wix-ready article

• Video scripts

• Supporting content

All aligned to your Learn Teach Master structure:

• Title

• Intro

• What Is X

• Why It Matters

• Key Takeaways

Step 4: Approve (Human-in-the-Loop)

Jenny pauses and asks:

“Approve or reject?”

This is implemented as a manual stage in GitLab Pipelines.

👉 You stay in control without slowing the system down.

Step 5: Publish

Once approved, Jenny:

• Publishes to Wix via MCP

• Embeds videos

• Stores content in Git

Step 6: Amplify

Optional but powerful:

• Push to LinkedIn

• Schedule posts

• Drive traffic to content

Step 7: Learn

Jenny tracks:

• Engagement

• Performance

• Topic success

And feeds that back into the next cycle.

👉 This is where automation becomes intelligence

⚙️ GitLab Pipeline Example

Here’s the real backbone of the system:

stages:

  - discover

  - generate

  - approve

  - publish

discover:

  stage: discover

  script:

    - python jenny.py discover

  artifacts:

    paths:

      - topic.json

generate:

  stage: generate

  script:

    - python jenny.py generate topic.json

  artifacts:

    paths:

      - article.md

approve:

  stage: approve

  script:

    - python jenny.py request_approval article.md

  when: manual

publish:

  stage: publish

  script:

    - python jenny.py publish article.md

  when: manual

🔥 Why This Matters

Most people are using AI like this:

• Prompt → Output → Done

That’s not a system.

Jenny changes the game:

She decides what to do, executes it, and improves over time.

This creates:

✅ Consistency

No more “what should I write next?”

✅ Scale

Content generation without burnout

✅ Strategy

Every output aligned to intent

✅ Autonomy

Minimal human intervention, maximum control

🧠 The Real Insight

This isn’t about blogging.

It’s about building:

An Intent-Driven Content Engine (IDCE)

A system that:

• Thinks

• Acts

• Learns

• Evolves

🚀 Key Takeaways

• Replace manual workflows with intent-driven systems

• Use Claude Code as the reasoning engine

• Use MCP for real-world integrations

• Use GitLab Pipelines as your automation backbone

• Keep a human-in-the-loop for control

• Build feedback loops to evolve over time

⚡ Final Thought

You’re no longer just creating content.

You’re building a system that creates with purpose, with direction, and with momentum.

And once it’s running…

It doesn’t stop.