Summary of "Agentic Coding - Workflow & Cline Demo"

Context and goal

Focus: using agentic coding (goal-oriented AI coding agents) to speed up enterprise software development while preserving quality, security, and business rules.
Claimed impact example:

A front-end rewrite (AngularJS → React) was reduced from ~31 developer days (~$50k) to ~11 days (~$17k) when using the right tools, models, and workflows.

Klein — open-source VS Code extension; core demoed agentic coding interface. Emphasis on agent-oriented (goal-driven) workflows rather than autocomplete.
LLMs referenced: Anthropic Claude (Sonnet / Claude series), Google Gemini 2.5 Pro.
On-prem / private model hosting (e.g., Bedrock / GCP private deployments) for enterprise data/security constraints.
MCP (Model Context Protocol) — integrates LLMs with external data sources and tools.
Dev tools server (custom) — lightweight service agents call to fetch fresh, authoritative data (latest Docker tags, package versions, GitHub Actions/Golang package versions, etc.).
Other dev tools mentioned (examples from transcript): VS Code, Git, Jira, npm, Docker, TypeScript, Tailwind / shadCN component templates, Snyk / Checkmarx (security scanning).
Note: some transcript names may be auto-generated or misspelled.

Stored as structured templates (speaker favors pseudo-XML) to bias agent behavior:
- Examples: testing patterns, internal doc links, deprecated API avoidance, spelling/locale, diagram theming, company style.
Version-controlled (git) so teams can share and update rule sets per client or repo.
Toggleable in the Klein UI.

Agents call tools (via MCP) to fetch up-to-date facts the model lacks (e.g., current stable package versions) or to supply prebuilt templates (component skeletons).
This augments the LLM’s knowledge with deterministic, current information and private repo data when needed.

Reusable prompt templates stored locally or centrally and shared via git.
Example workflow capabilities:
- Create phased checklist / implementation plan for a rewrite.
- Upgrade dependencies: read repo file tree and code, generate component/architecture diagrams (Mermaid), check for outdated packages and security issues (while advising deterministic security tools), and produce a phased development plan and checklist.
After plan generation, commands like “Begin phase one” prompt the agent to implement tasks.

Load repo context: file tree and key files (index, tsconfig, tests).
Agent calls dev tools server to fetch latest package versions and other authoritative data.
Agent generates a phased implementation plan and diagrams (Mermaid) that capture upgrade paths and tasks.
Agent executes tasks for phase one: updates packages (npm install), applies TypeScript best practices, runs the app.
Embedded browser (within Klein/Climb) + multimodal model: agent performs exploratory UI testing (clicks elements, inspects JavaScript console), collects screenshots, and attempts autonomous fixes for issues found.
Agent updates the plan/checklist to mark completed items.
Human review required: models are predictive—engineer oversight, rule & prompt tuning, and deterministic security checks remain essential.

Share plans via git repositories (simple, versioned) or integrate with Jira for task decomposition; agents can chunk epics into tasks.
Teams often keep rule/workflow repos that developers clone. Klein is being extended with centralized workflow/rule distribution.
Team dynamics:
- An agent-assisted developer can feel like a small team (e.g., “me + two engineers”).
- Carving work by repository is currently easier to avoid clashes.
- Typical dev team sizes mentioned: ~5–11 people focusing on repo-level work.

Use structured rules (pseudo-XML) to bias model outputs; models respond well to structure.
Augment models with deterministic tooling (package/version fetchers, security scanners) to avoid hallucination and out-of-date package choices.
Use private model hosting (VPC) or open-source agent tools to meet enterprise security and compliance requirements.
Spend proportionally more time on planning (clear phased plans) than jumping into coding; better plans enable reliable handoff between agents or humans.
Don’t treat agentic coding as autopilot—maintain human-in-the-loop review and testing, especially for security-critical checks.

Phased checklist generator for redevelopment projects (e.g., Angular → React).
Upgrade dependencies template:
- Scan repo, list outdated packages, call dev-tools to fetch latest versions, create diagrams, produce a development plan.
Component/widget templates for front-end stacks (Tailwind / shadCN, etc.) accessible via tools.
Automation hooks to create/modify Jira tickets from epics (task decomposition).

The team tested many tools (transcript mentions examples like Cursor, Re/code, Windsurf — some names may be mis-transcribed).
Klein stood out because it is:
- Open-source and auditable.
- Deployable within customer private clouds (no external data leakage).
- Focused on agentic, goal-oriented workflows rather than purely autocomplete.
The speaker uses other agent frameworks for more complex tasks; Klein is part of a broader toolset.

Primary demo presenter: an engineer / R&D lead (unnamed) demonstrating Klein and agentic workflows.
Sam: panelist/respondent answering questions about tool selection and enterprise use.
Grant: another presenter mentioned.
Audience/questioners referenced: Tabish (asked about sharing plans), Chris (asked about team size).
Tools/systems referenced: Klein (VS Code extension), Anthropic Claude (Claude Sonnet/Claude series), Google Gemini 2.5 Pro, MCP (Model Context Protocol), dev tools server, Git, Jira, Snyk/Checkmarx (security tools).
Note: some product names in subtitles may be auto-generated or misspelled.