Workshops: Agentic Engineering Practices
Guardrails for Coding Agents: Linters, Types & Pre-Commit Hooks
An agent that receives precise, automatic feedback after every edit corrects itself before a human ever sees the code. This workshop shows development teams how to build that feedback stack from formatters, linters, type checkers and hooks, so agent output arrives in review already clean and reviewers can concentrate on logic and design.
Who is this workshop for?
- Tech leads and senior developers responsible for code quality
- Teams whose agent-generated pull requests keep failing review on avoidable issues
- Platform and developer experience teams maintaining repository templates
- Teams with legacy code that has little or no static analysis
- QA engineers who want defects caught before testing starts
What you will take away
- Design a layered feedback stack of formatter, linter, type checker and fast tests that agents run automatically after each change.
- Configure pre-commit hooks and agent-side hooks so violations surface before code is committed, with CI as the final gate.
- Tighten type checking step by step, for example strict TypeScript or mypy, while agents migrate existing code in batches.
- Turn recurring review comments into custom lint or Semgrep rules that an agent writes and tests.
- Detect and prevent workarounds such as blanket disable comments, skipped hooks or loosened configuration.
Agenda
Module 1
Why deterministic checks make agents better
- Agents work from feedback: the faster and clearer, the better
- Fast versus slow checks and where each belongs
- Exercise: an inventory of the checks in your repository
Module 2
Formatter, linter, type checker
- Tool choice per stack, e.g. Prettier, ESLint or Biome, Ruff, golangci-lint, Clippy, Checkstyle
- Exercise: switch on a stricter configuration and let the agent work through the findings
- A baseline for legacy code so only new violations block
Module 3
Hooks before and after the agent acts
- The pre-commit framework, Husky and lint-staged
- Agent hooks, for example Claude Code hooks that run checks after every file edit
- CI as the final, non-negotiable gate
Module 4
Custom rules for your conventions
- From review comment to lint rule
- Exercise: a Semgrep or ESLint rule written and tested by the agent
- Architecture and dependency rules as lightweight checks
Module 5
Stopping the workarounds
- Spotting suppressions, any types, swallowed errors and skipped hooks
- Rules for exceptions in AGENTS.md or CLAUDE.md
- Tracking suppressions over time as a quality signal
The cheapest quality lever you have
Every rule a machine checks is a comment no reviewer has to write. With agents the effect multiplies: a coding agent that sees a type error or lint message immediately fixes it in the same session, whereas a human review would have needed a round trip of hours or days.
Error messages matter as much as the rules themselves. A message that states what is wrong and which alternative is allowed steers the agent to the right fix instead of leaving it to guess or suppress the warning.
Tools we work with
We follow your stack and your existing configuration. Typical building blocks are:
- JavaScript and TypeScript: ESLint, Biome, Prettier, tsc in strict mode
- Python: Ruff, mypy or Pyright
- Java and Kotlin: Checkstyle, SpotBugs, detekt, ktlint
- .NET: Roslyn analyzers and nullable reference types
- Cross-language: Semgrep, pre-commit, SonarQube or comparable platforms
- Agents: Claude Code, OpenAI Codex, Cursor and GitHub Copilot with their instruction files and, where available, hooks
Frequently asked questions
Will strict rules slow our developers down?
Fast checks such as formatting and linting of changed files usually take only seconds and save far more time in review. Slower analyses belong in CI, and we help you split them so local feedback stays fast.
Can agents simply switch the rules off?
They can, and some try when a check keeps failing. Clear instructions, protected configuration files, CI checks for new suppressions and review of configuration changes make this visible and rare.
We have thousands of existing violations. Where do we start?
With a baseline: existing findings are recorded and only new ones block. Agents then reduce the backlog module by module in small pull requests, so quality improves without a development freeze.
Workshop
Get in touch
Which review comment would you most like never to write again?
Tell us roughly how many people will join and pick dates that work – we will get back to you within 24 hours with a proposal for content, format and schedule.
Prefer to talk first?
15 minutes, free and without obligation – with our AI Trainers and AI Code Engineers.
Book a call for free (opens in new tab) +49 761 519 751 50 (24/7)Request a training / workshop
Workshop: Guardrails for Coding Agents: Linters, Types & Pre-Commit Hooks · 1 day
More workshops
- Workshops: Agentic Engineering PracticesMulti-Agent Software Engineering: Roles, Parallel Work, Merging
- Workshops: Agentic Engineering PracticesBug Triage & Backlog Reduction with AI Agents: Workshop
- Workshops: Agentic Engineering PracticesMVP in a Week with Coding Agents: 2-Day Greenfield Workshop
- Workshops: Agentic Engineering PracticesAgentic Coding Dojo: Katas for Regular Team Practice
- Workshops: Agentic Engineering PracticesTDD with Coding Agents: Hands-On Red-Green-Refactor Training
- Workshops: Agentic Coding Tools in DepthChoosing & Piloting Coding Agents: Workshop for Engineering Leads
