There’s a term making the rounds in developer circles: vibe coding. It’s that feeling when you’re prompting an AI, it generates something that looks right, you run it, it works (mostly), and you ship it. The vibes are good. The code… might be less so.

I came across a framework this week that names this problem directly: the “Agentic Coding 6 Principles and 28 Practices”. It’s one of the clearest articulations I’ve seen of how to move from “AI helped me write this” to “I built this with AI responsibly.”

The Fireball Problem

The authors use a compelling metaphor: AI-generated code is like casting a 3rd-circle fireball. Impressive, fast, gets the job done for demos and prototypes. But production systems need meteor-strike precision—powerful, sophisticated, and reliable.

The gap between fireball and meteor isn’t about AI capability. It’s about human accountability.

Six Principles That Actually Work

1. Developer Accountability

The AI is a tool. You’re the one who commits the code. “The AI did it” is never a valid excuse for bugs in production.

2. Understand and Verify

Never merge code you don’t understand. This sounds obvious, but when AI generates 200 lines in seconds, the temptation to skim is real.

3. Prioritize Security and Confidentiality

Don’t paste your API keys into ChatGPT. Don’t share customer data with Claude. This principle saves careers.

4. Maintain Code Quality and Standards

AI doesn’t know your team’s conventions unless you tell it. Your job is to ensure consistency.

5. Human-Led Design and Critical Thinking

AI assists. Humans architect. Core system design can’t be delegated to an LLM.

6. Recognize AI’s Limitations

Hallucinations, biases, outdated knowledge—know the failure modes and plan for them.

The Practices That Differentiate

What makes this framework practical is the accompanying 28 practices. A few stood out:

Multi-agent workflows: Use one agent to generate, another to review. This catches surprising blind spots.

Task-specific strategies: Before each task, consciously decide: is this AI-driven (refactoring, test generation) or human-led (core architecture, security logic)? Different approaches for different risks.

Adaptation under failure: When the AI keeps suggesting broken solutions, don’t keep prompting harder. Switch models, provide broader context, or step back to think yourself.

Why This Matters for TypeScript

I’ve been researching agentic coding in TypeScript specifically, and these principles map beautifully:

  • Types as verification: TypeScript’s type system is a natural safety net. Type errors catch AI hallucinations before runtime.
  • Project structure as context: Your tsconfig.json and directory structure can encode conventions that help AI understand your codebase.
  • Contracts between agents: If you’re building multi-agent systems, TypeScript interfaces make data contracts explicit and checkable.

The Real Shift

Vibe coding isn’t going away. Sometimes you should just prompt fast and iterate. But knowing when to shift from fireballs to meteors—from demos to production—is the skill that separates developers who use AI from developers who leverage AI.

The framework isn’t about restricting AI usage. It’s about matching the level of rigor to the level of risk.

Worth reading in full: agentic-coding.github.io

What’s your experience? Have you developed your own “principles” for working with AI coding tools, or do you mostly vibe it?