DEV Community: KochC

The Future of AI Engineering Is Not Autonomous - It's Accountable

KochC — Sun, 31 May 2026 09:00:10 +0000

The future of AI engineering is not autonomous coding. It is accountable coding.

There is a lot of excitement around autonomous agents.

Agents that plan.
Agents that code.
Agents that test.
Agents that ship.

But for serious engineering, autonomy alone is not the goal.

Accountability is.

A useful AI engineering system should answer

Why was this change made?
Which requirement does it implement?
Which tests verify it?
What did the Red Team find?
Which risks remain?
What evidence supports release?
Where was the human approval?

That is where Agile V comes in

Agile V combines the speed of AI-assisted development with the discipline of engineering verification.

It does not ask humans to manually do everything.

It asks humans to make the important decisions, approve the critical gates, and review evidence that the system produces along the way.

That is the balance we need

→ AI for execution.

→ Humans for judgment.

→ Evidence for trust.

If AI is going to build real products, we need more than faster code.

We need verified engineering.

Explore the projects

agile-v-skills

Agent skills for traceable requirements, independent Red Team verification, human gates, and compliance-ready evidence.

→ github.com/Agile-V/agile_v_skills

agentic-agile-v

A practical scaffold for running AI engineering with structured briefs, evidence bundles, validation gates, and risk-based workflows.

→ github.com/Agile-V/agentic_agile_v

From vibe coding to verified engineering.

The Problem Is Not AI Hallucination - It's Missing Evidence

KochC — Sat, 30 May 2026 20:12:23 +0000

The problem is not AI hallucination. The problem is missing evidence.

When AI makes a mistake, we often call it a hallucination.

But in engineering, the deeper issue is usually simpler:

There was no controlled process around the output.

No clear requirement.
No independent verification.
No traceability.
No risk record.
No approval gate.
No evidence bundle.

That means the problem is not only that AI can be wrong.

The problem is that teams often have no reliable way to prove when AI is right.

Agile V is designed around that gap

Instead of letting an AI agent jump directly from prompt to code, Agile V introduces a verified engineering loop:

Clarify intent.
Create traceable requirements.
Build only against approved requirements.
Generate tests independently.
Red-team the result.
Capture decisions and risks.
Accept only with evidence.

This changes the role of AI

AI is no longer just a code generator.

It becomes part of a controlled engineering workflow.

That matters especially for regulated, safety-relevant, long-lived, or high-risk systems where correctness alone is not enough. You also need to explain how correctness was established.

Explore the projects

agile-v-skills

Agent skills for traceable requirements, independent Red Team verification, human gates, and compliance-ready evidence.

→ github.com/Agile-V/agile_v_skills

agentic-agile-v

A practical scaffold for running AI engineering with structured briefs, evidence bundles, validation gates, and risk-based workflows.

→ github.com/Agile-V/agentic_agile_v

From vibe coding to verified engineering.

AI Coding Is Not the Hard Part Anymore

KochC — Fri, 29 May 2026 06:53:27 +0000

AI coding is not the hard part anymore.

AI can already generate code quickly.

That is no longer the real bottleneck.

The harder question is:

Can we trust what was generated?

In traditional engineering, we do not accept a change just because someone wrote it. We ask:

What requirement does it satisfy?
What assumptions were made?
What tests prove it works?
What risks remain?
Who reviewed and approved it?

AI-generated work should be held to the same standard.

That is the idea behind Agile V.

Agile V brings structure into AI-assisted development

By connecting:

→ Intent

→ Requirements

→ Implementation

→ Tests

→ Traceability

→ Evidence

→ Human approval

The goal is not to slow AI down.

The goal is to make AI-generated engineering work reviewable, repeatable, and trustworthy.

Because in real products, "the agent said it is done" is not enough.

Explore the projects

agile-v-skills

Agent skills for traceable requirements, independent Red Team verification, human gates, and compliance-ready evidence.

→ github.com/Agile-V/agile_v_skills

agentic-agile-v

A practical scaffold for running AI engineering with structured briefs, evidence bundles, validation gates, and risk-based workflows.

→ github.com/Agile-V/agentic_agile_v

From vibe coding to verified engineering.

How Do We Know AI-Generated Code Is Ready?

KochC — Thu, 28 May 2026 07:30:10 +0000

How do we know an AI-generated change is actually ready?

Not just "the code looks good."

Not just "the tests pass."

Not just "the agent says it's done."

We need evidence:

→ What requirement was implemented?

→ What changed?

→ What was tested?

→ What risks remain?

→ Who approved the result?

That is the idea behind Agile V: bring traceability, independent verification, and evidence gates into AI-assisted development.

Explore the projects

agile-v-skills

Agent skills for traceable requirements, independent Red Team verification, human gates, and compliance-ready evidence.

→ github.com/Agile-V/agile_v_skills

agentic-agile-v

A practical scaffold for running AI engineering with structured briefs, evidence bundles, validation gates, and risk-based workflows.

→ github.com/Agile-V/agentic_agile_v

From vibe coding to verified engineering.

From Vibe Coding to Verified Engineering

KochC — Wed, 27 May 2026 11:30:10 +0000

AI agents should not just generate code.

They should produce evidence.

That is the core idea behind Agile V:

→ Requirements before implementation

→ Independent verification

→ Traceability from intent to test

→ Human gates before release

→ Evidence bundles instead of after-the-fact documentation

Explore the projects

agile-v-skills

Agent skills for traceable requirements, independent Red Team verification, human gates, and compliance-ready evidence.

→ github.com/Agile-V/agile_v_skills

agentic-agile-v

A practical scaffold for running AI engineering with structured briefs, evidence bundles, validation gates, and risk-based workflows.

→ github.com/Agile-V/agentic_agile_v

From vibe coding to verified engineering.

Agile V: Turning AI Agents into Verifiable Engineering Systems

KochC — Tue, 26 May 2026 21:58:40 +0000

AI coding is fast. But fast code without requirements, tests, traceability, and evidence is just vibe coding with confidence.

That's why we built Agile V: a framework for turning AI agents into verifiable engineering systems.

Two open-source projects

agile-v-skills

Agent skills for traceable requirements, independent Red Team verification, human gates, and compliance-ready evidence.
→ github.com/Agile-V/agile_v_skills

agentic-agile-v

A practical scaffold for running AI engineering with structured briefs, evidence bundles, validation gates, and risk-based workflows.
→ github.com/Agile-V/agentic_agile_v

The principle

Conversation discovers intent.

Structured artifacts control implementation.

Evidence controls acceptance.

Star the repos, try them in your next AI-assisted project, and help make AI engineering more trustworthy.

My First Post

KochC — Tue, 26 May 2026 21:13:58 +0000

This is an example article for the marketing tool.

You can write markdown here — bold, italic, links, and more.

Section Heading

Use any OpenCode model from Open WebUI, LangChain, or the OpenAI SDK — with a one-line install

KochC — Fri, 27 Mar 2026 19:27:16 +0000

If you use OpenCode, you already have GitHub Copilot, Ollama, Anthropic, Gemini, and other providers configured in one place.
The problem: every other tool in your workflow — Open WebUI, LangChain, Chatbox, Continue, Zed, your own scripts — needs the same models re-entered with their own API keys and base URLs.
I built opencode-llm-proxy to fix this. It's an OpenCode plugin that starts a local HTTP server on http://127.0.0.1:4010 and translates between whatever API format your tool uses and OpenCode's model list.

Install

npm install opencode-llm-proxy

Add to opencode.json:

{ "plugin": ["opencode-llm-proxy"] }

Start OpenCode — the proxy starts automatically.

Supported API formats

All formats support streaming.

Format	Endpoint
OpenAI Chat Completions	`POST /v1/chat/completions`
OpenAI Responses API	`POST /v1/responses`
Anthropic Messages API	`POST /v1/messages`
Google Gemini	`POST /v1beta/models/:model:generateContent`

Examples

OpenAI SDK (Python) — route to Ollama

from openai import OpenAI
client = OpenAI(base_url="http://127.0.0.1:4010/v1", api_key="unused")
response = client.chat.completions.create(
    model="ollama/qwen2.5-coder",
    messages=[{"role": "user", "content": "Write a binary search in Python."}],
)
print(response.choices[0].message.content)

Anthropic SDK (Python) — route to GitHub Copilot

import anthropic
client = anthropic.Anthropic(base_url="http://127.0.0.1:4010", api_key="unused")
message = client.messages.create(
    model="github-copilot/claude-sonnet-4.6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain the CAP theorem."}],
)
print(message.content[0].text)

OpenAI SDK (JavaScript)

import OpenAI from "openai"
const client = new OpenAI({ baseURL: "http://127.0.0.1:4010/v1", apiKey: "unused" })
const response = await client.chat.completions.create({
  model: "anthropic/claude-3-5-sonnet",
  messages: [{ role: "user", content: "Explain async/await." }],
})
console.log(response.choices[0].message.content)

Open WebUI

Settings → Connections → set API Base URL to http://127.0.0.1:4010/v1. All your OpenCode models appear in the model picker instantly.

LangChain (Python)

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
    model="anthropic/claude-3-5-sonnet",
    openai_api_base="http://127.0.0.1:4010/v1",
    openai_api_key="unused",
)
response = llm.invoke("What are the SOLID principles?")
print(response.content)

How it works

Each request:

Authenticates (optional bearer token via OPENCODE_LLM_PROXY_TOKEN)
Resolves the model ID — provider/model notation, bare model ID, or Gemini URL path
Creates a temporary OpenCode session
Sends the prompt via the OpenCode SDK
Returns the response in the same API format as the request Model IDs come from GET /v1/models, which returns all configured providers in OpenAI list format:

curl http://127.0.0.1:4010/v1/models | jq '.data[].id'
# "github-copilot/claude-sonnet-4.6"
# "anthropic/claude-3-5-sonnet"
# "ollama/qwen2.5-coder"

Configuration

Variable	Default	Description
`OPENCODE_LLM_PROXY_HOST`	`127.0.0.1`	Bind address. Set to `0.0.0.0` to expose on LAN or Docker.
`OPENCODE_LLM_PROXY_PORT`	`4010`	TCP port.
`OPENCODE_LLM_PROXY_TOKEN`	(unset)	Bearer token required on every request.
`OPENCODE_LLM_PROXY_CORS_ORIGIN`	`*`	`Access-Control-Allow-Origin` for browser clients.

GitHub · npm