Capstone: mlship v2 + Pattern Paper

The culmination of ROOT. 4 months. Ship the OSS artifact (mlship v2) + the writing artifact (pattern paper). Stand the final exam. Graduate. ~16 weeks, ~200 hrs.

Phase 30 is the synthesis phase — the last 4 months of Year 5 and the proof that everything since the Master Plan actually compounded into capability. The deliverable is two artifacts that have to coexist: mlship v2 (the OSS proof you ship at production quality) and the pattern paper (the Staff/Principal proof you reason at depth). One without the other won’t graduate you. Real engineers ship code; Staff/Principal engineers ship code and writing that other engineers cite.

The structural discipline of this phase is parallel work on two clocks. mlship v2 is execution: 4 months from architecture to Show HN, scoped tight at 2 frameworks done excellently rather than 6 done badly. The pattern paper runs in parallel on the same 4-month timeline, in a different mode — research, drafting, external review, conference submission. Skipping either clock means missing graduation. Plan accordingly: the budget is 200 hours, the deadlines are real, and there is no Phase 31.

This is also the phase where the Studio composition recipes finally land end-to-end — mlship deploy ./model.pkl → URL becomes the simplest of the five and the easiest 60-second demo on the live studio.abukix.dev from P29. All the prior Y5 phases — P26, P27, P28, P29 — are integration substrates the capstone consumes. See patterns/ml-and-ai/ for the patterns the paper draws from.

---

Prerequisites

• Phase 29 complete — Abukix Studio public, platform-ctl public, aiops marketed
• 4.5+ years of operational experience across the platform
• You accept: two distinct artifacts and a final exam. mlship v2 is the OSS proof you can ship at production quality. The paper is the Staff/Principal proof you can reason at depth. Both are non-negotiable for graduation.

---

Why this phase exists

ROOT’s exit ramp at Year 5 is Staff/Principal AI Platform Engineer (or one of the elective endpoints — see “What’s Next” below). The capstone is what makes that role real — not just learned skills, but shipped artifacts other engineers see + use + cite.

The two artifacts are non-substitutable

A capstone with only mlship v2 makes you a senior engineer who shipped a useful tool. A capstone with only the pattern paper makes you a writer with infrastructure opinions. The Staff/Principal AI Platform Engineer title — the one the Master Plan pins to the Year 5 exit ramp — requires both: the OSS that proves you ship, and the writing that proves you reason. The Final Exam panel will probe whichever artifact is weaker. Don’t give them an obvious target.

---

The two artifacts

Artifact 1: mlship v2 (the OSS, primary)

One command to deploy any ML model to production. The launch artifact. See projects/mlship/plan for the long-form design history.

The review’s scope discipline: 2 frameworks done excellently (sklearn + HuggingFace text-generation), not 6. Other frameworks land as v2.1, v2.2, v2.3 quietly post-launch. Quality over breadth at launch.

mlship v2 spec (4 months of work):

CLI:
  mlship deploy ./model.pkl
    → auto-detect sklearn (covered in v0)
    → containerize with sklearn runtime
    → deploy to local Docker OR K8s+KServe (cloud target options)
    → expose REST API
    → wire Prometheus metrics
    → return URL

  mlship deploy hf://meta-llama/Llama-3.2-1B
    → fetch from HuggingFace
    → quantize (AWQ option)
    → deploy via vLLM
    → expose /v1/chat/completions (OpenAI-compatible)
    → return URL

  mlship list / logs / rollback / destroy

Architecture:
  - Auto-detection engine (framework + shape)
  - Template engine (per-framework Dockerfile + K8s manifest)
  - Plugin model (custom frameworks; NOT shipped at launch — v2.x)
  - Local dev mode (Docker only, no K8s required)
  - Cloud mode (AWS Fargate + GCP Cloud Run)

OSS launch:
  - GitHub repo with comprehensive README
  - 3-minute demo video (sklearn → URL in 60s; HF → URL in 90s)
  - Show HN post
  - LinkedIn announcement
  - Blog post: "Why mlship exists"
  - Documentation site (mkdocs or VitePress)

NOT in v2 (deferred to v2.x):
  - PyTorch / TensorFlow / ONNX detection (quietly added post-launch)
  - Plugin model for custom frameworks
  - Multi-region deploy
  - Authentication / billing

Quality bar: the 2 supported framework paths must work flawlessly + look polished. A user trying mlship deploy ./model.pkl should feel like magic.

Artifact 2: Pattern Paper (the writing, secondary)

Long-form, Staff/Principal-grade writing on ONE pattern you’ve now operated deeply. Conference-grade quality (USENIX SREcon? KubeCon? QCon? ACM Queue?).

Pick ONE of:

• “Zero-trust mesh in homelab: a 5-year postmortem”
• “Lakehouse + agents: when AIOps eats your runbooks”
• “The agent loop as a state machine: what we got wrong”
• “Pattern-first learning: 5 years of patterns over tools”

Paper spec (parallel to mlship work):
- 5,000-10,000 words
- Specific examples from ROOT's operational history
- Cites primary sources (papers, RFCs, your own postmortems)
- Reviewed by 2+ external readers before publication
- Published: company blog, your blog, conference submission

Why the paper specifically requires external readers

You can fool yourself into thinking writing is clear; you can’t fool a peer reviewer who reads it cold. The two-external-reader requirement isn’t ceremony — it’s the audit that separates Staff/Principal-grade synthesis from senior-grade documentation. Pick readers who will be unsparing (one inside your domain, one outside it). The paper that survives external review is the artifact that survives a tool change, a job change, and ROOT itself.

---

Phase 30 structure (4 months)

Month	mlship v2 focus	Paper focus
57	Architecture + sklearn auto-detect end-to-end	Outline + research; pick pattern + venue
58	HuggingFace text-gen path + vLLM integration	First draft
59	CLI polish + Cloud mode (Fargate + Cloud Run) + docs site	Review draft with 2+ readers; revise
60	Launch (Show HN, LinkedIn, blog, video)	Submit / publish

---

1. PROBLEM

The capstone tests synthesis: can you take 5 years of learning + a real shipped artifact + a real piece of writing to a level that Staff/Principal engineers recognize as peer-level?

---

2. PRINCIPLES (this phase is execution + delivery)

You’ve internalized the patterns. Phase 30 is integration + delivery. The principles that matter now:

• Ship over polish — perfectionism kills capstones; ship at “good enough to be useful,” then improve
• Real users > stars — get 5 real users to deploy a real model; their feedback > 1000 stars
• Writing is thinking — the paper forces you to articulate what you actually believe
• The deadline is real — Month 60 ends; graduation requires both artifacts shipped

---

3. TRADE-OFFS

Decision	Option A	Option B	When
mlship language	Go (consistent with Y1+platform-ctl)	Python (faster ML iteration)	Python wins for ML iteration; you have Go elsewhere already
Paper venue	Conference (status, slow)	Blog (immediate, less reach)	Both
Launch strategy	One big launch	Soft launch + iterate	Soft: less pressure, more learning
mlship scope	2 frameworks (sklearn + HF)	6 frameworks	2 done excellently > 6 half-baked

---

4. TOOLS

You have all the tools by now. Just ship.

---

5. MASTERY (synthesis)

5.1 mlship v2 operational checklist

[ ] github.com/abukix/mlship public + active
[ ] README + docs site (mkdocs or VitePress)
[ ] Auto-detect: sklearn + HuggingFace transformers (text-generation)
[ ] Containerize: per-framework optimized Dockerfile (multi-stage, distroless when possible)
[ ] Register with MLflow if available; standalone mode if not
[ ] Deploy: K8s+KServe (basecamp), Docker local, AWS Fargate, GCP Cloud Run
[ ] LLM-aware: route HF text-gen models to vLLM
[ ] API: REST for traditional models; OpenAI-compat for LLMs
[ ] Observability: Prometheus metrics out-of-the-box
[ ] Tests: 80%+ coverage; one integration test per framework path
[ ] CI: GitHub Actions builds + releases binaries via GoReleaser
[ ] Demo video: 3-minute screencap, "from .pkl to served URL in 60s"
[ ] Show HN post with the video
[ ] Blog post on abukix.dev: "Why mlship exists"
[ ] LinkedIn announcement (you have the brand by now from P29)

5.2 Pattern paper checklist

[ ] Pick pattern + venue by end of Month 57
[ ] Outline + reference list by mid-Month 57
[ ] First draft complete end of Month 58
[ ] Reviewed by 2+ external readers by mid-Month 59
[ ] Revised end of Month 59
[ ] Published / submitted by mid-Month 60
[ ] Cross-linked from abukix.dev + LinkedIn

5.3 Integration with the rest of Y5

mlship v2 deploys to basecamp via KServe. Studio (P29) shows mlship-deployed models in the portal. AIOps (P28) can trigger mlship rollback <name> via basecamp-mcp on drift alert.

By Month 60, the 5 composition recipes are runnable end-to-end on the live Abukix Studio. mlship is the simplest one: mlship deploy ./model.pkl → URL is the entire flow.

---

6. CONTRIBUTE (ongoing)

Year 5 PR target: contribute to one CNCF project you’ve used heavily (KServe, Kubeflow, vLLM, MCP reference). The Y5 contribution should be substantial — not a typo fix.

---

7. OPERATE

You’ve been operating for 5 years. This phase: keep doing it. The platform shouldn’t fall over while you’re shipping the capstone.

---

Validation criteria

[ ] mlship v2 public on GitHub with active commits
[ ] mlship v2 has demo video + Show HN post
[ ] mlship v2 has at least 5 real users (not just stars)
[ ] Pattern paper published (blog at minimum; conference if accepted)
[ ] Paper has 2+ external readers' acknowledgments
[ ] All Year 5 patterns DEEP
[ ] Year 5 Final Exam (= ROOT Final Exam) passed
[ ] **GRADUATION**

---

ROOT Graduation

60 months. 30 phases. 5 yearly exit ramps.
~50 patterns deepened through deliberate practice.
One complete data/AI platform built from kernel to LLM.
Capstone OSS shipped + pattern paper published.
~10 OSS projects with stars + users.
Multi-disciplinary depth (Linux, networking, databases, ML, platform, security, agents).

Staff/Principal AI Platform Engineer (or chosen elective endpoint).

---

What’s Next (post-ROOT)

You’re 30-31 years old. The depth lasts 30 years. The exit-ramp options are:

1. Stay in big-co Staff/Principal track — apply for the role; the artifacts + writing + OSS make you stand out
2. Found AI startup — mlship is potentially a product; the platform skill is the moat
3. Applied AI lab — Anthropic / OpenAI / similar; you have the depth
4. Kubeflow / OSS maintainer — your contributions opened the door

Whichever you pick — the depth is yours forever.

→ Update The Story with the graduation chapter. → Start the post-ROOT chapter of whatever comes next. → Year 5 Final Exam = ROOT Final Exam

---

Anti-patterns

Anti-pattern	Why
6-framework mlship at launch	Diluted quality; v2.x will add others
Paper in 2 weeks	Forces shallow writing; this is Staff/Principal-grade synthesis
Skipping demo video	The single highest-leverage content artifact
Soft-launch + ghost	Once you announce, sustain the support window
mlship without 5 real users tested before launch	Real-user feedback is the moat

---

Patterns deepened this phase

By Month 60: all ~50 patterns DEEP. Phase 30 is execution; the deep practice happened in Phases 1-29.