Status: Active development. A functioning, single-page operations dashboard that drives an AI-assisted creative production pipeline for short-form animated content. The dashboard prototype works and has been used to run the pipeline end to end. The broader "TV network" (a published catalogue of finished episodes, distribution, and audience) is still being built and is not claimed here.
NewGenAI TV Network is my flagship project: an attempt to design and operate an AI-assisted production studio for short-form animated content under the working channel name NewGen AI Swim (a 16+/TV-14-equivalent, platform-compliant short-form concept for YouTube, TikTok, and Instagram).
The piece that exists and functions today is the Agent Ops Dashboard — a single
React component (src/AgentOpsDashboard.jsx, ~1,000 lines) that turns a loose creative
idea into a structured, reviewable production package by moving it through a fixed,
gated, twelve-step pipeline. Each step calls a Claude model with a purpose-built system
prompt, shows the result for human review, and only unlocks the next step once the
human is satisfied.
This repository is a portfolio artifact. It documents the system I designed and the working prototype I built. It is not a packaged product or a deployed service.
Producing short-form content at any consistency runs into three problems:
- Blank-page cost. Generating good ideas repeatedly is hard, and quality drifts.
- Inconsistency across steps. Idea → script → shot list → prompts → captions is a long chain; without structure, later steps lose the intent of earlier ones.
- No memory. Each session forgets what was already tried, rejected, or liked, so the same ideas resurface and personal taste is never learned.
The dashboard addresses these with a single opinionated pipeline, explicit human approval gates, and a cross-session memory that records rejected ideas, established characters, and "taste history" to steer future generation.
| Area | Status |
|---|---|
| 12-step pipeline UI + state machine | Built and working (confirmed by source) |
| Per-step Claude prompt calls | Built and working (confirmed by source) |
| Human approval gate on the script step | Built and working (confirmed by source) |
| Cross-session memory (rejects / characters / taste) | Built and working (confirmed by source) |
| Short-Form Viability (SFV) scoring + story/channel scoring | Built and working (confirmed by source) |
| "Bring Your Own Idea" refinement path | Built and working (confirmed by source) |
| Downstream "cascade" warnings on edits | Built and working (confirmed by source) |
| Natural-language creative direction on active stages | Built and working (CODE-CONFIRMED — DirectionPanel in source) |
| Accept / reject / regenerate / restore controls on each stage | Built and working (CODE-CONFIRMED — all four in DirectionPanel) |
| End-to-end pipeline test completed | Done — first approved pilot: My Lawyer Is Feral (FILE-DOCUMENTED — project overview) |
| Actual media generation (voice/music/image/video) | Not built — the dashboard generates prompts, not media |
| Published episodes / audience / revenue / distribution | Not built / not claimed |
See PROJECT_STATUS.md for the detailed, evidence-labeled breakdown.
Full project overview (goals, creative direction, technical challenges, roadmap) in
docs/NEWGENAI_PROJECT_OVERVIEW.md.
┌───────────────────────────────────────────────────────────────┐
│ Agent Ops Dashboard (single React component) │
│ │
│ Creative DNA library ──┐ │
│ (abstract craft │ per-step system prompts │
│ principles) ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ 12-STEP PIPELINE (locked → ready → active → done) │ │
│ │ 1 Ideas → 2 Outline → 3 Script [HUMAN GATE] → │ │
│ │ 4 Shot List → 5 Voice → 6 Music → 7 Images → │ │
│ │ 8 Video → 9 Captions → 10 Checklist → 11 Package → │ │
│ │ 12 Memory │ │
│ └──────────────────────────────────────────────────────┘ │
│ │ ▲ │
│ ▼ │ │
│ Claude model call Memory + analytics store │
│ (per step, with (rejected ideas, characters, │
│ tailored system prompt) taste history, episode log) │
└───────────────────────────────────────────────────────────────┘
See architecture/ARCHITECTURE.md for the full
description, including the dependency/cascade map and the memory schema.
- Generate Ideas — produces a batch of 6 concepts (3 series-pilot, 2 standalone, 1 wildcard), each scored and tagged, generated in two batches with anti-repetition.
- Outline — expands the selected idea.
- Script — writes the short-form script. ← human approval gate.
- Shot List — shot-by-shot plan.
- Voice Prompts — text prompts labeled for ElevenLabs (no ElevenLabs API call).
- Music Prompts — text prompts labeled for Suno AI (no Suno API call).
- Image Prompts — text prompts labeled for Leonardo AI (no Leonardo API call).
- Video Prompts — text prompts with CapCut references (no video tool API call).
- Captions & Tags — platform-specific captions and hashtag packages.
- Post Checklist — pre-publish checklist (includes Drive and Airtable steps as checklist line items; the dashboard does not call Drive or Airtable APIs).
- Final Package — compiles all completed sections into a single copyable production-planning and prompt package. Includes a "Mark as Published" action that logs episode metadata for future analytics. This is a planning and prompt package, not a rendered, edited, or publishable video.
- Memory — an interactive navigable workspace (always accessible) for reviewing and managing the cross-session taste profile: taste history, tone preferences, established characters, production lessons, and rejected concepts. This profile is injected into future idea-generation prompts automatically.
Steps 5–8 produce text prompts targeting specific downstream tools (named in the UI and prompt text). The dashboard does not call those tools or render media. No ElevenLabs, Suno AI, Leonardo AI, or video API integrations exist in the current source.
The pipeline is deliberately not fully autonomous. Every step renders its output for
review, and steps unlock through an explicit state machine (locked → ready → active → done). The script step has a hard approval gate: downstream steps stay locked until
the human explicitly approves the script. If an upstream step is later regenerated, the
dashboard raises cascade warnings naming the downstream stages that are now
potentially misaligned, so the human decides what to re-run. This human-in-the-loop
design is a core part of the system, not an afterthought.
- A shared base system prompt establishes the channel's identity and platform constraints.
- A Creative DNA library holds abstract craft principles (character magnetism, "first-frame priority", "controlled-unhinged" tone, short-form retention behavior). These are deliberately abstract — no copyrighted show titles, characters, or episodes.
- Each pipeline step composes the base prompt + the relevant DNA + step-specific instructions, and several steps inject memory context (recently rejected titles, established characters, taste history, tone preferences) to steer output.
See prompts/README.md for how the prompt system is organized
and what is intentionally not published.
A single-page, dark-themed React UI: a left rail showing the 12 steps with live status
dots, a main panel for the active step's generation/output/review, score bars (10
story/channel-fit metrics) and a Short-Form Viability readout per idea, copy-to-clipboard
on every output block, and inline error/warning handling for truncated or unparseable
model responses. Recommended screenshots are listed in
screenshots/README.md.
CODE-CONFIRMED by the dashboard source: the full 12-step pipeline, the state machine
gating, per-step Claude calls, the script approval gate, cascade warnings, the
DirectionPanel with accept/reject/regenerate/restore, cross-session memory, SFV and
story/channel scoring, Bring Your Own Idea, two-batch idea generation, structured JSON
validation, and the Final Package compiler.
FILE-DOCUMENTED (project overview, not independently verified by code): an
end-to-end pipeline run was completed using the first approved pilot concept,
My Lawyer Is Feral, as a validation test.
(Source: docs/NEWGENAI_PROJECT_OVERVIEW.md.)
- No integration with actual voice/music/image/video generation services (it emits prompts only).
- The dashboard depends on a host runtime that provides a storage API and the model endpoint; it is not yet a standalone, independently deployable app with its own backend/auth.
- No automated tests in this artifact.
- The wider "network" (catalogue of finished/published episodes, distribution, audience) does not exist yet.
I am the product owner, designer, and operator of this system. My contributions:
- Product & creative direction — defining the channel concept, tone, and the "controlled-unhinged / first-frame-priority" creative philosophy encoded in the DNA library.
- System & workflow design — defining the 12-step pipeline, the gating rules, the human approval gate, and the cascade-on-edit behavior.
- Prompt engineering — designing the layered system prompts and the structured JSON output contract per step.
- Evaluation design — defining the scoring dimensions (story, channel fit, and Short-Form Viability).
- Testing, troubleshooting & recalibration — running the pipeline, diagnosing
failures (e.g. truncated/
max_tokensresponses, unparseable JSON), and iterating. - Documentation — the docs in this repo.
See AI_ASSISTANCE.md for an honest split of human vs. AI work.
This project was built with heavy AI assistance (Claude / Claude Code, and other AI
tools). I directed the design, made the product and creative decisions, evaluated and
corrected outputs, and iterated — but I did not hand-write every line of the
dashboard code. Full disclosure in AI_ASSISTANCE.md.
- Structure plus human gates beats full autonomy for keeping creative quality and intent intact across a long generation chain.
- Cross-session memory and explicit anti-repetition meaningfully reduce idea drift.
- Designing an explicit output contract (typed JSON per step) makes model output far easier to validate, score, and recover from when it fails.
- Failure handling (truncation, bad JSON) is most of the real engineering.
- Replace the host-runtime dependencies with a real backend (own model proxy + storage).
- Wire selected prompt steps to actual generation tools, behind the same human gates.
- Add automated tests and an evaluation harness over the scoring system.
- Build out the "package → publish" tail end of the pipeline.
NewGenAI-TV-Network/
├── README.md ← this file
├── PROJECT_STATUS.md ← evidence-labeled status of every claim
├── AI_ASSISTANCE.md ← human vs. AI contribution disclosure
├── PRIVACY_REVIEW.md ← privacy/security audit of this repo
├── FILE_MANIFEST.md ← every file, where it came from, why it's here
├── .gitignore
├── src/
│ └── AgentOpsDashboard.jsx ← the working dashboard (the core artifact)
├── architecture/ ← system architecture write-up
├── prompts/ ← prompt-system overview (no proprietary prompts dumped)
├── docs/ ← supporting docs
├── screenshots/ ← (add screenshots — see screenshots/README.md)
└── examples/ ← (optional sanitized example outputs)
The component expects a host runtime that provides a key-value storage API and a Claude
model endpoint (it was authored in such an environment). To demo it locally you would
need to supply those (a small storage shim and your own authenticated model proxy). The
fastest way to convey the system for a portfolio is screenshots / a short screen
recording of the pipeline running — see screenshots/README.md
for the exact shots to capture.
- This repo contains one working component plus documentation — not a full app, not a deployed service, and not a media catalogue.
- It does not generate audio/video; it generates prompts.
- It depends on an external runtime to actually run.
- No published episodes, audience, revenue, customers, or third-party integrations are
claimed. Where this README describes behavior, it is backed by the source in
src/.