Agentic Coding: Frameworks Build Agency and Speed Kills Latency
Structured agentic frameworks constrain beginners, amplify experts, and foster internalization of delegation skills, while ultra-fast models like Codex Spark end latency debt for interactive pair programming.
Mindset Barriers and the Skill Issue Spectrum
Engineers adopting coding agents face anxiety, fear, and existential dread, often oscillating between dismissing outputs as "slop cannon" and blaming user "skill issue." David House, from G2I, argues both poles hold truth: poor prompts yield junk, but mastery differentiates reliable results. Beginners lack intuitive agentic practices absent from traditional education, leading to disempowerment—reacting to outputs rather than steering them. Successful adoption requires shifting to agency: encoding engineering judgment into prompts, reviews, and delegation scopes.
House's core claim: Agentic frameworks should constrain inputs for beginners (preventing mistakes like rewriting entire codebases) and amplify inputs for experts (leveraging nuanced judgment). Frameworks reveal hidden agentic practices, make reasoning/output reviewable, and train effective delegation—e.g., step-by-step tasks over epic-scale prompts.
"For a beginner, an agentic framework should constrain their input. ... For an expert ... an agent framework should actually amplify their input."
G2I's project enforced an agentic workflow from day one: /brief (agent as PM interviews user for product brief), /spec (agent as architect for technical spec), /code or /test-driven (uses docs as prompts), /review (verifies implementation), /draft-pr (saves time). This staged handoff embeds judgment, produces reviewable artifacts, and builds trust via better outputs.
Internalization Through Structured Practice
Case studies from G2I engineers illustrate progression from hesitation to intuitive mastery:
- Ava (new to work AI): Trusted ChatGPT for personal ideas but feared reputational risk at work. G2I's expectation + techniques yielded trustworthy output; she internalized to build custom sub-agents for testing.
- Lucy (4 years exp.): Succeeded on migrations but failed on complex personal projects (duplicated/unreviewable code). Learned to explicitly prompt for tests, runs, and judgment. Now uses fluid "interview loops"—iterative chats embedding steering and self-correction—without rigid docs.
"You have to tell the agent to do the right thing. You have to tell the agent to write tests ... The practice of agentic programming is building the judgment you have about how to be an engineer into prompts and into the review mechanisms."
- Antoine (15 years, meticulous founder): Hyper-vigilant post-early failures; TDD skill built trust iteratively, tuning skepticism contextually. Can't articulate changes but credits "hundreds of nuances" from reviewing agent outputs for refined code-writing skills.
- Dale (4 years): Used ChatGPT as tutor (explanations, not generation) due to context/trust gaps. Post-10k-line PR disaster, narrowed scopes. Now hand-writes precise prompts (20 mins) encoding framework guardrails, reviews PRs like teammate work.
All started disempowered but gained driver's seat control. Frameworks bootstrap this; internalization lets users evolve beyond them.
Onboarding Juniors Without Abandoning Them
Juniors aren't doomed sans prior AI skills. Andy (fresh grad): Faculty banned AI; tutors pushed tutor-like use. G2I culture shocked him, but senior reviews on pre-code docs (briefs/specs) encoded judgment, boosted implementations, and mentored via high-leverage artifacts. Agents tutor tirelessly when seniors are busy. In 3 months, Andy matched 10-year vets:
"I was shocked to hear this was your first role out of school. You fit right in alongside folks with 10 years of experience."
Don't polarize ("AI-savvy juniors only"); mentorship + agents accelerates ramp-up.
Latency Debt Undermines Agentic Flows
Sarah Chiang (Cerebras Head of DevX) exposes why agentic coding frustrates despite smarter models: latency debt. Models ballooned (0.3B to 1T+ params), contexts to millions of tokens (4x input growth per Open Router/A16Z study of 100T real tokens), outputs 3x larger with reasoning tokens. Yet inference speed stagnates (50-150 tokens/sec across Gemini/Claude/Sonic). More tokens at same speed = exploding times (e.g., Claude's endless "reticulating splines").
"We've optimized our models faster than our infrastructure ... if the number of input tokens increases and the number of output tokens increases then the total time ... is also going to increase."
Cerebras/OpenAI's Codex Spark: 200 tokens/sec (20x faster state-of-the-art). Enables interactive pair programming: steer/verify in real-time, no "hit enter and lunch." Future models promise step-function speeds, unlocking workflows sans technical debt from machine-scale generations.
Key Takeaways
- Adopt frameworks like G2I's (/brief → /spec → /code → /review) or CRISPY/RP1 to constrain beginners, reveal practices, and train delegation.
- Encode judgment explicitly: Prompt for tests, runs, scopes; use interview loops for steering and self-correction.
- Narrow delegations—avoid epic PRs; review docs/PRs like teammate work.
- For juniors: Pre-code doc reviews by seniors + agents as tutors = fast ramp-up.
- Combat latency debt with fast inference (e.g., Codex Spark); treat agents as live pair programmers.
- Internalize via repetition: Progress from framework dependence to amplified intuition.
- Build trust iteratively: Better outputs → more delegation → superior results.
- Reject polarities—skill and slop exist; frameworks bridge to agency.
- Experiment: Slow down initially for reviewable outputs; prioritize speed to sustain joy.