<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Zeeshan Hanif on Medium]]></title>
        <description><![CDATA[Stories by Zeeshan Hanif on Medium]]></description>
        <link>https://medium.com/@zeeshan_hanif?source=rss-20ecfa7da880------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*VgbH6xleITj5quEY95suWw.jpeg</url>
            <title>Stories by Zeeshan Hanif on Medium</title>
            <link>https://medium.com/@zeeshan_hanif?source=rss-20ecfa7da880------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 22:57:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@zeeshan_hanif/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[I Got Tired of Vibe Coding, So I Rebuilt the SDLC as Twelve Agent Skills]]></title>
            <link>https://medium.com/@zeeshan_hanif/i-got-tired-of-vibe-coding-so-i-rebuilt-the-sdlc-as-twelve-agent-skills-229773eafb07?source=rss-20ecfa7da880------2</link>
            <guid isPermaLink="false">https://medium.com/p/229773eafb07</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Zeeshan Hanif]]></dc:creator>
            <pubDate>Wed, 23 Sep 2026 16:02:59 GMT</pubDate>
            <atom:updated>2026-09-23T16:06:47.288Z</atom:updated>
            <content:encoded><![CDATA[<h4>An open-source kit that turns “prompt and pray” into a disciplined pipeline — from requirements interview to a deployed, verified system, with every decision traceable on disk.</h4><h3>The problem nobody wants to admit</h3><p>Coding agents are extraordinarily good at writing code. They are bad at knowing <em>what</em> to write, <em>in what order</em>, and <em>whether it’s actually done</em>.</p><p>Left to itself, an agent improvises. It redesigns mid-build. It weakens a failing test until it passes. It loses its place between sessions. And it ships something that satisfies the last message in the chat rather than the requirement you started with.</p><p>Here’s how most AI-assisted projects actually get built today. You open a chat, describe an app in three sentences, and the agent starts generating. It makes a hundred small decisions — database shape, auth approach, folder structure, error handling — and tells you about none of them. Twenty minutes later you have something that runs. Two weeks later you have something nobody understands, including the agent, because the context that produced those decisions evaporated the moment the session ended.</p><p>For a weekend prototype, that’s genuinely fine. But the moment a project has to outlive the chat window that created it, the cracks show:</p><p><strong>There are no requirements — anywhere.</strong> Ask “does this handle password reset?” and the honest answer is “let me grep the code and find out.” The requirements exist only as a fossil record of prompts scattered across chat histories.</p><p><strong>Decisions have no memory.</strong> Why Postgres and not Mongo? The agent had a reason at 2:14 PM on a Tuesday, and it’s gone. A later session either rediscovers the reasoning or silently contradicts it.</p><p><strong>Context rot compounds.</strong> Long agent sessions degrade. So you start a fresh one — which knows nothing, because everything it needed lived in the previous session’s context window instead of on disk.</p><p><strong>Nothing verifies anything.</strong> The agent says “done, all tests pass.” Did it write tests that check the acceptance criteria, or tests that describe whatever the code happens to do? Without a requirement to trace back to, “the tests pass” is a statement about the tests, not the software.</p><p>None of this is new. Our industry spent fifty years building answers to exactly these problems: requirements specifications, architecture decision records, traceability matrices, independent acceptance verification, staged delivery. Most of that discipline was already eroding before agents arrived — the paperwork was expensive, and teams under deadline pressure dropped it first. Agents accelerated that retreat. When code arrives in seconds, the artifacts around it — the spec, the decision record, the traceability — become the slow part, and the part that gets skipped.</p><p>That’s the insight I couldn’t shake:</p><blockquote><strong><em>The traditional SDLC was never wrong — it was just too expensive for humans to run rigorously. Agents make it cheap.</em></strong></blockquote><p>An agent doesn’t groan at maintaining a traceability matrix. It doesn’t skip the architecture doc because of sprint pressure. The clerical burden that made heavyweight processes collapse under their own weight is precisely what LLMs are best at.</p><p>So I built it: <a href="https://github.com/zeeshanhanif/agentic-sdlc-kit"><strong>Agentic SDLC Kit</strong></a> — twelve Agent Skills that carry a project from <em>“I have an idea”</em> to a deployed, verified, maintainable system. They follow the open SKILL.md standard, so they run in Claude Code, Codex, and any other agent that loads skills.</p><figure><img alt="The Agentic SDLC Kit pipeline: five skills run once to take a project from requirements to a scaffolded repo; four more repeat once per feature; the orchestrator drives each cycle, initial deployment runs on demand, and pipeline-verify audits the documents at any time." src="https://cdn-images-1.medium.com/max/1024/1*_BC2yPxh9hz_CYVroBfHwA.png" /></figure><h3>One requirement, end to end</h3><p>Before the machinery, the thing the machinery exists for. Say the requirements interview captures a sentence like this:</p><blockquote><em>“People sign up with an email and a password.”</em></blockquote><p>Here is what that one sentence becomes as it moves through the pipeline, and the file each piece lands in:</p><figure><img alt="One requirement traced through eight skills: FR-AUTH-001 and UC-001 in the SRS, ADR-003 in the architecture, SCR-WEB-001 and SCR-WEB-002 in the UX foundations, FEAT-001 in the implementation plan, acceptance criteria and tasks in the technical design, screen designs in ui-design, checked tasks from implementation, and an Accepted verdict in the acceptance report." src="https://cdn-images-1.medium.com/max/1024/1*kDjIbQtIUJMWJM_N5bZl8g.png" /></figure><p>The trace shows eight of the twelve skills, because those are the ones that produce something for this requirement. Scaffolding and deployment work on the project as a whole, and the orchestrator and seam checker sit above every requirement rather than inside one.</p><p>Nothing in that chain is remembered. Every step is a document read from disk by a skill that may be running in a session opened ten minutes or ten days later. FR-AUTH-001 means the same thing at every step, and the traceability matrix says so:</p><figure><img alt="An excerpt of docs/rtm.md showing two rows, FR-AUTH-001 and FR-AUTH-002, with columns Req ID, Requirement, Priority, Status, Source, Use cases, Design ref, Plan ref and Test ref. Both trace to FEAT-001 and its acceptance report." src="https://cdn-images-1.medium.com/max/1024/1*SBHi_3Dg8ah7BLCe61R0uQ.png" /></figure><p>Each column is written by a different skill — more on that shortly.</p><h3>Running the pipeline</h3><p>The README walks through <a href="https://github.com/zeeshanhanif/agentic-sdlc-kit#running-the-pipeline-end-to-end">a complete run</a>, with the exact prompt that triggers each skill, in order. The first one is all you need to start. Open your agent on a new project and type:</p><blockquote>I’m kicking off a new project — help me gather and write up the requirements.</blockquote><p>Then see how different it feels when the agent interviews <em>you</em> before writing anything.</p><p>Every step after that is the same kind of sentence. Once the plan exists, the whole construction loop is four of them, repeated for each feature:</p><pre>Design the next feature from the plan.<br>Design the next feature&#39;s screens.<br>Implement the next feature from the plan.<br>Verify the next feature.</pre><p>Or hand the loop to the orchestrator with one: <em>“Run the loop until it hits something that needs me.”</em></p><h3>What makes this a kit and not twelve prompts</h3><p>Six contracts make the skills behave like one system. If you take nothing else from this article, take these — they apply to any multi-step agent system you build.</p><p><strong>1. Stable IDs, minted once, never recycled.</strong> FR-AUTH-007 in the SRS is the same ID the architecture cites, the plan schedules into a feature, the design turns into acceptance criteria, and the auditor signs off on. Six namespaces — requirements, use cases, decisions, screens, features, defects — all immutable. Removals are <em>tombstoned</em>, never deleted or renumbered, so every downstream reference stays resolvable forever.</p><p><strong>2. Source-gated traceability.</strong> A shared vocabulary is also a way to manufacture authority. A fabricated FR-AUTH-019 looks exactly like a real one — it reads as grounded, it survives review, and three documents later something depends on a requirement that was never written. A missing citation is visible; an invented one isn&#39;t, which makes it the more corrosive of the two failures by a wide margin. So the rule is blunt: <strong>a skill cites an ID only when the document that defines it is present.</strong> Where there&#39;s nothing to cite, a skill states its reasoning in prose and says so. That&#39;s prevention at write time; skill twelve catches at audit time whatever still slips through.</p><p><strong>3. The traceability matrix is a shared ledger with exclusive column ownership.</strong> Multiple skills write to docs/rtm.md, but each owns exactly one column and <em>appends, never overwrites</em>. Requirements owns the rows, planning owns Plan ref, architecture opens Design ref for the two design skills to extend, and acceptance-verification alone owns Test ref. A requirement&#39;s lifecycle reads left to right, and &quot;fully verified&quot; is <strong>computed</strong> from the intersection — never written into a cell by anyone.</p><p><strong>4. Position is computed from artifacts, never remembered.</strong> No skill keeps a pointer to “where we are.” A feature folder with a technical design is <em>designed</em>; add a UI design and it’s <em>ui-designed</em>; a fully-checked task list is <em>developer-done</em>; an accepted acceptance report is <em>verified</em>. That’s why a brand-new session lands in exactly the right place. Context rot stops mattering when context is reconstructed from disk.</p><p><strong>5. Escalate, don’t fork.</strong> When reality contradicts the design, a skill either implements the design’s intent or files an amendment against the owning document. It never quietly changes the spec. A feature needing a new entity is an architecture amendment. A screen needing an off-system color is a design-system amendment. No silent redesigns.</p><p><strong>6. Green is demonstrated, not asserted.</strong> Done-whens are executed. Suites are re-run cold by an independent auditor. Tests and coverage gates are never loosened to pass.</p><p>Two chains run the length of the pipeline, because they’re where agentic projects usually rot. <strong>Testing is decided once, at the top</strong> — the architecture picks the strategy, the frameworks, and the coverage stance, and everything downstream <em>realizes</em> that decision instead of re-deciding it. <strong>Configuration is a first-class artifact</strong> — scaffolding mints a config template per deployable unit, implementation extends it whenever a task needs a new variable, and deployment reconciles the templates against the real environment before deploying. Green pipelines stop dying on a missing environment variable.</p><p>All six contracts rest on one fact: everything the pipeline knows is in the repo. Here’s everything it writes, and which skill writes each file.</p><figure><img alt="The project tree after a full run: AGENTS.md at the root, and under docs/ the SRS, use cases, traceability matrix, architecture, UX foundations, design system, tokens, implementation plan, design manifest, scaffold and deployment notes, defect ledger and verify report, plus a features/FEAT-001-register folder holding technical-design.md, tasks.md, ui-design.md and acceptance-report.md. Each file is annotated with the skill that produces it." src="https://cdn-images-1.medium.com/max/1024/1*sed1WRmaZIwi3XoeEbtfZA.png" /></figure><h3>The linear phase — five skills that run once per project</h3><h4>1. requirements-engineering — the interview that becomes an SRS</h4><p>The pipeline’s entry point. Instead of transcribing what you happen to mention, it <strong>proactively enumerates</strong> the standard sub-requirements for each capability area and has you confirm, extend, or trim them. “User authentication” is never one line — it expands into sign-up, sign-in, email verification, forgot/reset password, logout, session expiry, lockout, rate limiting. A requirement catalog prompts the commonly-forgotten areas too, and it walks the standard quality categories — performance, security, reliability and the rest — so non-functional requirements come out <em>measurable</em>.</p><p>It produces a structured SRS, a use-case document, and the traceability matrix. Functional requirements use either <strong>EARS</strong> — five constrained sentence patterns — or classic “shall” statements; you choose <strong>once</strong>, before the first requirement is minted, and that choice binds every later amendment. Every run includes an <em>unwanted-behavior pass</em>, so error and failure counterparts become their own requirements instead of afterthoughts in prose. Amendments later add, modify, or tombstone requirements without disturbing the IDs already in flight.</p><p><strong>The benefit:</strong> “what did we agree to build?” has a canonical, citable answer before a line of code exists — and it can change later without destroying history.</p><h4>2. software-architecture — decisions with receipts</h4><p>Its governing principle: <strong>architecture is driven by quality attributes and constraints, not by technology.</strong> It elicits what actually forces decisions — scale, availability, consistency, security, team, timeline, lock-in tolerance — and derives the design, rather than reaching for a familiar stack first. With an SRS present it reads the requirements as the primary source and interviews only for the gaps; with use cases present it mines them for the runtime view, since exception flows reveal failure handling and actors reveal trust boundaries.</p><p>Output: an arc42-based document right-sized to the system, C4 diagrams as embedded Mermaid, and Architecture Decision Records with a “Requirements addressed” field citing the exact IDs that drove each decision. Plus the testing decisions above, and a deployment view recording the environment set and promotion order — the contract the deployment skill later executes.</p><p><strong>The benefit:</strong> “why Postgres?” now has a written answer with a requirement ID attached, and ADR supersession preserves the decision history instead of overwriting it.</p><h4>3. ux-foundations — the architecture of the UI</h4><p>The design-phase sibling to software-architecture. It derives the <em>structure and design language</em> of the UI rather than jumping to pixel-perfect screens, on the principle of <strong>one shared core plus a per-surface layer</strong> — so an admin portal, marketing site, and mobile app feel like one product without flattening their real differences. Personas come straight from the SRS’s user classes, and the SRS’s accessibility requirements are a non-negotiable bar: an imported palette that fails the contrast requirement gets adjusted, and the change is recorded.</p><p>The visual direction comes from one of four source modes:</p><ul><li><strong>Research</strong> — derive a new direction from scratch.</li><li><strong>Extract</strong> — read it out of reference images you drop in a folder.</li><li><strong>Ingest</strong> — take it from an existing design file or brand book.</li><li><strong>Connect</strong> — pull it over MCP from a design tool such as Claude Design or Figma.</li></ul><p>It always asks; detection tells it what’s <em>possible</em>, only you say what’s <em>wanted</em>. And every mode ends by playing back a proposed direction for confirmation, because extraction and research are approximations, never facts.</p><p>The <strong>fourth mode</strong> deserves a note, because it comes with an ordering constraint. By the time you reach this step you hold an SRS and an architecture document — a written account of who the users are, which surfaces exist, and what the accessibility bar is. Hand those documents, whole or in the relevant parts, to a design tool like Claude Design or Figma, generate a real visual design from them, and connect it over MCP. What ux-foundations pulls across is not screens but the language underneath them — tokens, styles, components.</p><p>The mode you choose also fixes the foundation’s provenance, and that is what the screen-level skill inherits two steps later: whether screens are registered from the design tool or generated fresh, and from where. <strong>So design-tool work belongs before ux-foundations, not after it</strong>. Generate a design once the foundation has already been set from a different source, and you own two design systems that don’t agree.</p><p>Three outputs with a strict authority split: ux-foundations.md (personas, IA, flows, screen inventory with stable SCR IDs), design.md (the render-time system a coding agent loads when building UI), and tokens.json (canonical W3C DTCG tokens — the single source from which design.md&#39;s CSS is derived).</p><p><strong>The benefit:</strong> downstream agents don’t improvise UI. Screens already have IDs, tokens already have values, components already have specified states.</p><h4>4. implementation-planning — from documents to build order</h4><p>The bridge from design to construction. Two principles: <strong>slice vertically, never horizontally</strong> — every unit of work cuts through UI, API, domain, and data to deliver something demonstrable, never “build all the tables” — and <strong>make the architecture executable before complete</strong>: build the walking skeleton first, not the easiest feature.</p><p>It produces epics and thin vertical slices, each with a stable FEAT-NNN ID and each tracing the requirements it implements, the use cases it realizes, and the screens it touches. Plus a risk- and dependency-ordered sequence, the first slice specified in full, and a <strong>Must-requirement coverage check</strong> — every Must-priority requirement lands in a slice or is consciously deferred. No silent gaps. It plans the whole app&#39;s breadth but details only what&#39;s next: depth-on-demand, not the waterfall trap.</p><p><strong>The benefit:</strong> “what do we build first, and why?” gets a defensible answer, and the plan doubles as the work queue every loop skill reads.</p><h4>5. project-scaffolding — the first skill whose output is a running system</h4><p>Scaffolding usually means “generate some folders.” This one runs the ecosystem’s <strong>official generators</strong> — discovering them and verifying their names and flags <strong>against live docs before first use</strong>, never from memory, which is what keeps the skill self-updating as frameworks change. The stack itself is an input, never a decision: the ADRs already chose it.</p><p>You get a real repo with module boundaries enforced by lint and import rules, a wired walking skeleton (UI shell → API → domain stub → database → back), a <strong>compose-first local stack</strong> with pinned images so a teammate or a fresh agent session starts the same system you did, CI, config templates, and a test harness running the frameworks the architecture named. Agent instructions live in AGENTS.md at the root, with CLAUDE.md holding nothing but a pointer to it — one source of truth instead of two that drift.</p><p>Then it <strong>verifies itself empirically</strong>: clean install, every unit builds, the skeleton test passes from a cold start, boundary rules hold, and every path in AGENTS.md resolves. Anything unfixable is flagged, never silently shipped.</p><p><strong>The benefit:</strong> construction starts from a repo that provably works, with the project’s conventions physically installed where fresh sessions will find them.</p><h3>6. initial-deployment — runs once, whenever you choose</h3><p>Scaffolding stops at deploy-<em>ready</em> by contract. This skill executes exactly those artifacts and gets the system <strong>running in the cloud</strong>. It runs once, and you choose when: on the bare skeleton right here, mid-loop after a few features, or once the whole plan is built. It gates nothing downstream.</p><p>Doing it early is what I’d recommend — deploying the walking skeleton proves the system deploys before features pile on. Deploying later gives its measurement phase more to measure, at the cost of a first push that ships N features at once, with many more candidate causes when something breaks. Either way, once it has run, CD carries every push after it.</p><p>Two gates define its character:</p><ul><li><strong>Money.</strong> The deployment plan — resources, environments, rough cost class — is played back for one explicit confirmation. Nothing billable exists before that nod.</li><li><strong>Credentials.</strong> The skill preflights that your provider CLI is authenticated and blocks with instructions if it isn’t. It never asks for, stores, or writes a secret <em>value</em> — it wires the provider’s own secret mechanism and proves it with a non-secret canary.</li></ul><p>It provisions the infrastructure in dependency order, extends CI into CD, and runs the skeleton’s own test against the deployed environment to confirm it actually works.</p><p><strong>The benefit:</strong> the gap between “works on my machine” and “runs in production, verifiably” becomes a skill instead of a weekend of improvisation.</p><h3>The Construction Loop — four skills, once per feature, forever</h3><p>Here the pipeline changes species. Everything so far runs once per project; these four run once per <em>feature</em>, in a fresh context each time, reading everything they need from disk.</p><figure><img alt="The construction loop: detailed-design, ui-design, feature-implementation and acceptance-verification arranged on a track. Each transition produces a file — technical-design.md, ui-design.md, a fully checked tasks.md, acceptance-report.md. A verified feature returns to the start, where the next feature enters from implementation-plan.md. Rework and design-defect routes loop back inside the track." src="https://cdn-images-1.medium.com/max/1024/1*efy7vJyw1RL9_Lxjp_2cgg.png" /></figure><h4>7. detailed-design — one feature, fully specified</h4><p>Turns planned intent into a buildable technical design. Three principles: the <em>what</em> is fixed upstream and this skill designs the <em>how</em>; <strong>the live codebase is a mandatory input, not an obstacle</strong> — feature twelve is designed against code that has evolved past the skeleton, and where code and documents diverge, <strong>reality wins</strong> (with the divergence noted); and depth here and only here.</p><p>Per feature it writes technical-design.md — API contracts, schema migrations within the entities architecture already owns, acceptance criteria derived from the requirement statements — and tasks.md, an ordered, individually verifiable program. Each task&#39;s done-when is <strong>classified at design time</strong>: behavioral tasks get test-artifact done-whens, structural tasks get demonstration done-whens, so implementation executes the classification instead of improvising ceremony tests. New entities or boundary changes escalate to an architecture amendment, never invented locally.</p><p><strong>The benefit:</strong> the implementation agent receives a program, not a vibe.</p><h4>8. ui-design — the adapter between design tools and code</h4><p>The presentation half of each feature’s design, and structurally an <strong>adapter</strong>. How screens actually get designed varies wildly, so it routes across strategies per screen — following the source the foundation established — while emitting one uniform contract: docs/design-manifest.json, the screen registry that everything downstream reads regardless of what produced each screen. All design-tool variance is absorbed here; no downstream skill ever learns what a Figma node is.</p><p>It has three modes:</p><ul><li><strong>Anchor</strong> — right after ux-foundations, design two or three compositionally demanding screens to prove the design system actually <em>composes</em> before features build on it.</li><li><strong>Per-feature</strong> — the loop step.</li><li><strong>Re-verification</strong> — after a design-system amendment, re-check the affected screens.</li></ul><p>Screens conform to the design system or escalate. An off-system color is either corrected or the <em>system</em> is amended upstream — never forked locally.</p><p><strong>The benefit:</strong> the pipeline works whether you have a designer, a Figma file, or nothing at all, and implementation never has to guess which design is authoritative.</p><h4>9. feature-implementation — the disciplined builder</h4><p><strong>tasks.md is the program; this skill is the interpreter.</strong> It executes the feature&#39;s tasks autonomously, one at a time in order, against the live codebase, ending <em>developer-done</em>. It carries seven disciplines, each targeting a named failure mode of agentic implementation:</p><ul><li><strong>The program is fixed.</strong> Improvisation is escalation, not initiative.</li><li><strong>Disk is the memory.</strong> Checkbox state <em>is</em> the position, and every iteration must be executable in a brand-new session.</li><li><strong>Fix-loops are bounded.</strong> Three attempts per task, each needing a changed hypothesis, then an honest stop — unchecked box, failure note, an explicit WIP commit a fresh session can pick up cold.</li><li><strong>Scope is this feature.</strong> No drive-by refactors.</li><li><strong>Conventions hold by construction.</strong> Frameworks inherited from the harness; UI built through tokens rather than raw values.</li><li><strong>Git is the checkpoint.</strong> One commit per completed task, so the log reads as the execution log of the task list.</li></ul><figure><img alt="An excerpt of tasks.md for FEAT-001-register: tasks T3, T4, T5 and T7, each ticked, each with a Done-when line — an integration test for the transaction, unit tests for the password policy and hasher, and contract tests for the register endpoint, citing AC, FR and NFR IDs." src="https://cdn-images-1.medium.com/max/1024/1*R3qugIPLU3YYi2aVeqAd2A.png" /></figure><p>And the seventh, my favorite — the <strong>anti-fake-green rule</strong>. Tests are never weakened, skipped, deleted, or edited to pass, and where coverage is enforced, the threshold, its scope, and its exclusion lists are equally off-limits. A red gate means missing tests, not a config to lower. Fixing a genuinely buggy test <em>toward the design</em> is legitimate and recorded; fixing it <em>toward the code</em> is the forbidden move in costume.</p><p>Repeated blocking on one task is treated as a meta-signal that the <em>design</em> has a systematic problem — it recommends going back to detailed-design rather than burning more attempts.</p><p><strong>The benefit:</strong> the speed of autonomous implementation, with guardrails against the specific ways autonomous implementation cheats.</p><h4>10. acceptance-verification — the independent auditor</h4><p>The skill that makes the whole traceability story pay off. It runs after implementation and answers, without the implementer’s investment: <em>does this feature actually satisfy its requirements?</em></p><p>Its central rule is <strong>derivation, not trust</strong>. Every check is re-derived from the authoritative documents — acceptance criteria cross-checked against the verbatim SRS and use-case statements — <strong>never</strong> from task checkboxes, delivery summaries, or any session’s claimed greens. Those are the artifacts under audit, not evidence. <em>Claims are exhibits; observations are evidence.</em></p><p>So it audits each criterion for coverage and faithfulness, checks that the test actually exercises the behavior, runs an independent anti-fake-green review over the feature’s commit range, and re-executes every suite cold — feature tests, whole-repo, E2E, the coverage gate exactly as CI runs it. It verifies side-effect requirements by observation, inspecting the audit log’s entries rather than trusting a 200.</p><figure><img alt="An excerpt of the acceptance report’s audit table for FEAT-001-register: criteria AC-1 to AC-5 and AC-8, each with the requirements it encodes, the tests that cover it, an audit verdict of faithful, and the observed result, such as a live 409 email_taken response or no orphan user after a forced rollback." src="https://cdn-images-1.medium.com/max/1024/1*-heT9EuAnb2GDf-mVRfo7A.png" /></figure><p>Auditor and mechanic stay separate: findings <strong>route</strong>, and the skill never fixes production code. The one thing it may change is the measurement — a weak test corrected toward the criterion, never toward the code. If the faithful test then fails, that’s a rework finding: the system working as designed. Three verdicts come out of it:</p><ul><li><strong>Accepted</strong> — every criterion traced to a passing, faithful test.</li><li><strong>Rework</strong> — the implementation doesn’t satisfy a criterion; routes back to the builder.</li><li><strong>Design defect</strong> — the criterion itself is wrong or unbuildable; routes back upstream.</li></ul><p>A feature is verified whole or not yet. Partial acceptance isn’t a verdict.</p><p><strong>The benefit:</strong> “done” stops being the builder’s opinion and becomes an auditable fact.</p><h3>Above and across — the two meta skills</h3><h4>11. sdlc-orchestrator — the thin loop driver</h4><p>With eleven skills in play, something has to answer “what runs next?” This one does — and it’s <strong>deliberately thin</strong>. Every loop skill already resolves its own position; the orchestrator adds only the <em>global</em> position, the invocation, and the routing. If logic here starts to look like design or build logic, it belongs in a stage skill instead.</p><p>It computes rather than stores — there is no orchestrator state file — and drives the loop at whatever scope you ask for: one stage, one feature cycle, or run-until-blocked. It announces its resolution before acting (<em>“FEAT-006 is at ui-designed; invoking feature-implementation”</em>) rather than presenting a menu, which would invite off-sequence violations of the plan’s dependency order.</p><p>It routes outcomes: rework loops back through implementation and re-verification, <strong>bounded at two rework cycles</strong> before surfacing — an auditor and a builder disagreeing repeatedly is a design-quality signal, not something to grind through. Change requests walk the amendment chain top-down so a feature is never minted without its requirements. Bugs become a defect-ledger entry, a <strong>failing test first</strong>, a scoped fix, then re-verification.</p><p>And the design constraint I’m proudest of — <strong>its absence changes nothing.</strong> Every skill stays independently invocable. The orchestrator is composition on top, not wiring inside.</p><h4>12. pipeline-verify — the seam checker</h4><p>Tier one of verification is inside every stage skill; each verifies its own contract at delivery. This is tier two: the seams <em>between</em> documents that no single stage can see — a citation written correctly against a document another skill later amended, a requirement every stage individually handled but no stage ever covered, a manifest locator that rotted when a heading moved.</p><p>It’s mechanical only, read-only, and derived-output-only. It checks that every cited ID resolves; that no active work cites a tombstoned item; that there are no orphans, meaning requirements nothing touches and screens nothing renders; that the RTM’s rows, column ownership, and computed verification hold; and that the architecture’s named frameworks and coverage stance are <strong>actually realized in CI</strong>.</p><p>Findings come out classified as error, warning, or info, grouped by <strong>owning skill</strong> and specific enough to fix without re-deriving. Missing documents scope their checks out and are reported as <em>skipped</em>: absence of evidence is never reported as cleanliness.</p><p><strong>The benefit:</strong> document rot — the thing that kills every documentation-heavy process — gets caught mechanically instead of discovered six weeks later.</p><h3>Do you need all twelve?</h3><p>No. The pipeline is built for a system you intend to keep, but every stage right-sizes its own output — a CRUD tool gets a tight architecture document, not the full arc42 treatment. A reasonable minimum: requirements → architecture → plan → scaffolding, then the loop. Add the two design skills when there’s meaningful UI, deployment when it needs to be reachable, the orchestrator when you’re tired of driving by hand, and the seam checker once there’s enough traceability to be worth auditing. Run only requirements-engineering and stop, if that&#39;s the part that helps.</p><h3>What actually changes</h3><p>Put together, the kit inverts the default AI-development experience on every axis that was broken.</p><figure><img alt="Two-column comparison. Vibe coding: prompt to code; decisions disappear; context lives in chat; fresh session starts from zero; agent declares done; tests describe the implementation; documentation drifts. Agentic SDLC Kit: requirement to traceable artifacts to code; ADRs persist, citing the requirements behind them; state lives on disk; fresh session reads its position from disk; independent auditor verifies; tests derive from acceptance criteria; checker catches drift mechanically." src="https://cdn-images-1.medium.com/max/1024/1*OsYierDxe08uWYtTpxyv_g.png" /></figure><p>The deeper point is the one I started with: this isn’t nostalgia for heavyweight process. It’s arbitrage. The traditional SDLC encoded decades of hard-won lessons about how software projects fail, and we priced it out of reach by making humans do the clerical work. Agents changed the price. The discipline is affordable again — and it turns out rigorous process is exactly what makes autonomous agents <strong>auditable</strong>, because every claim they make becomes checkable against a document they didn’t write.</p><h3>Get the kit</h3><p>The kit is open source under Apache 2.0 at <a href="https://github.com/zeeshanhanif/agentic-sdlc-kit"><strong>github.com/zeeshanhanif/agentic-sdlc-kit</strong></a>. The skills CLI installs it in any agent that loads skills — Claude Code, Codex, Cursor and others:</p><pre>npx skills add https://github.com/zeeshanhanif/agentic-sdlc-kit --skill &#39;*&#39;</pre><p>Name one skill instead of &#39;*&#39; to try it alone — for example, just the requirements interview:</p><pre>npx skills add https://github.com/zeeshanhanif/agentic-sdlc-kit --skill requirements-engineering</pre><p>In Claude Code, you can also install it as a single plugin:</p><pre>/plugin marketplace add zeeshanhanif/agentic-sdlc-kit<br>/plugin install agentic-sdlc-kit@zeeshanhanif</pre><p>The plugin bundles all twelve as one unit, because they share an ID vocabulary and a traceability matrix with per-column ownership.</p><p>I’d genuinely like to hear where it breaks for you. That’s how the next twelve improvements get found.</p><p>Some of the improvements are already underway: I’m now extending the kit with <strong>hooks</strong> and <strong>agents</strong> alongside the skills.</p><p><em>If you’re building agentic systems and this resonated, follow along — I’m writing more about loop engineering, document-driven agent pipelines, and turning SDLC discipline into services-as-software.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=229773eafb07" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Another City Embraces Tech Education of Pakistani Youth]]></title>
            <link>https://medium.com/@zeeshan_hanif/another-city-embraces-tech-education-of-pakistani-youth-87bd5751b9d7?source=rss-20ecfa7da880------2</link>
            <guid isPermaLink="false">https://medium.com/p/87bd5751b9d7</guid>
            <category><![CDATA[piaic]]></category>
            <category><![CDATA[pakistan]]></category>
            <category><![CDATA[president-of-pakistan]]></category>
            <dc:creator><![CDATA[Zeeshan Hanif]]></dc:creator>
            <pubDate>Sat, 02 Nov 2019 14:08:06 GMT</pubDate>
            <atom:updated>2019-11-02T14:08:06.480Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*tzK_k_qfHXaa8V9_iyRdDA.jpeg" /><figcaption>PIAIC’s COO, Mr. Zia Khan addressing the students during Islamabad Entry test on Aug 5th, 2019</figcaption></figure><p>While <a href="https://en.wikipedia.org/wiki/PIAIC">Presidential Initiative for Artificial Intelligence and Computing (PIAIC)</a>’s Karachi and Islamabad classes are moving forward full steam, <a href="https://en.wikipedia.org/wiki/PIAIC">PIAIC</a> is initiating the program in Faisalabad, as well. “President <a href="https://en.wikipedia.org/wiki/Arif_Alvi">Dr. Arif Alvi</a> has given us a go-ahead!”, <a href="https://en.wikipedia.org/wiki/PIAIC">PIAIC</a>’s Chief Operating Officer, <a href="https://en.wikipedia.org/wiki/Zia_Khan">Mr. Zia Ullah Khan</a>, said beaming, “We’re very excited! We have a great team in place in Faisalabad and we’re looking forward to getting the show going.”</p><p>“Sir Zia”, as he is affectionately known to his students, is the charismatic motivator, the technical lead and the “man behind the vision” of PIAIC, that is single-handedly training over 17,000 students currently in Pakistan. It’s goal of training 100,000 students in emerging technologies like AI, Blockchain, Cloud Native and Internet of Things (IoT) with the resources and the backing of a visionary leader like the President himself, to bring it to fruition.</p><blockquote>“This is a Dynamic movement. We’re not stopping at a 100,000 students or the four technologies we have taken up. We’re actively working on developing programs in Quantum Computing, Design Thinking and Agile. We already have a program in 5G ready to go for PIAIC.” -Zia Ullah Khan, COO, PIAIC</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R8W0HWur3Vt2mKGLRSj7JQ.jpeg" /><figcaption>Director, Women Empowerment Division of PIAIC, Ms. Hira Khan at Jinnah Sports Complex, Islamabad</figcaption></figure><p>“The mainstay of the program, which could be termed “radical”, if not outright revolutionary, is the belief that everyone, regardless of their circumstance in life, be it their social or economic status, race, religion, or gender, especially gender that should hinder in them getting trained under this program.”, the program’s head of women’s empowerment division, <a href="https://pk.linkedin.com/in/hira-khan-76523540">Ms. Hira Khan</a> added. “If they are willing to learn, that is the only thing they need past our basic qualification.”</p><p>The program, unlike many others, have no pre-conditions, high entrance barriers of degrees and money, and is available to all students on a strict merit basis. Pakistan, being a conservative society, often frowns upon mixing the two genders, even in instructional settings. There have been other programs developed that have limited their admissions for males only, that have limited opportunities for women, who benefit more by leveraging technology to earn from home.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jLOxjowFOwJS4Nz9QIXoVA.jpeg" /><figcaption>PIAIC’s Secretary General, Mr. Kazi Rahat Ali addressing the students at Islamabad Entry Test on Aug 5th, 2019</figcaption></figure><p>The high ambitions and commitment to the program were further confirmed by the organization’s Secretary General, Mr. Kazi Rahat Ali, in a recent interview. “I must admit that we’re playing catch up with our neighbors in tech frontier, but we’re very committed to doing it.”</p><blockquote>“Renowned professor Dr.Andrew Ng (<a href="https://www.andrewng.org/">https://www.andrewng.org</a>), a Chinese English computer scientist, executive, investor, entrepreneur, whose ideas about how developing nations can join the 4th Industrial Revolution spoke to me.”</blockquote><blockquote>- Mr. Kazi Rahat Ali, Secretary General, PIAIC</blockquote><p>“We’re taking a three-pronged approach to succeed in our mission. Our first prong will be to skip over the intermediary technologies and <strong>leapfrog</strong> into the future by adopting AI and latest technologies. Our second prong would be the use of ‘Open Source Technologies’. It will not only provide us with universal access to the software and hardware for manipulation to ensure system security, but will also enable our youth to develop low cost and easily reproducible equipment that can be modified to meet the unique needs of users in the local market. And our final prong will ensure that <strong>We</strong> <strong>Infuse Technological Competence As a Grassroot Movement. </strong>It is my firm belief that<strong> </strong>a top-down formal educational model like most formal learning via Major Educational Institutions and Universities alone won’t deliver us at the end of the day.”, Mr. Rahat Ali said.</p><p>PIAIC will conduct ist’s Faisalabad Entry test on November 3rd, 2019 at at University of Agriculture Faisalabad (UAF). You can get further information about the program at <a href="https://www.piaic.org/">piaic.org</a> and watch related videos at <a href="https://www.youtube.com/watch?v=IFHpUZe_A50">PIAIC’s official Youtube Channel.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=87bd5751b9d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>