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

  1. 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
  2. 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
  3. 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
  4. 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
  5. 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

Dates that work for you (optional)

Suggestions about 2 weeks ahead – pick as many as you like

Reply usually within 24 hours · jocapps is ISO 27001 certified · Privacy