Can you recommend code quality and linting platforms for enforcing coding standards in CI and the IDE?

Yes — here are solid options for enforcing coding standards both in CI and directly in the IDE.

Best general-purpose choices

1. SonarQube / SonarCloud

• Best for: broad code quality, code smells, bugs, security issues, maintainability
• CI: strong support via scanners in GitHub Actions, GitLab CI, Jenkins, Azure DevOps, etc.
• IDE: plugins for IntelliJ, VS Code, Visual Studio, Eclipse
• Good fit if: you want one platform for quality gates, metrics, and technical debt tracking

2. ESLint + Prettier / Stylelint / RuboCop / etc.

• Best for: language-specific linting and formatting
• CI: run as part of build/test pipelines
• IDE: excellent support via editor extensions
• Good fit if: you want strict, fast feedback with developer-friendly autofix
• Notes: not a single platform, but often the most effective setup when paired with CI enforcement

3. Code Climate

• Best for: maintainability and review-focused quality signals
• CI: integrates well with PR checks
• IDE: less central than Sonar/linters, but useful in the workflow
• Good fit if: you want code review annotations and static analysis coverage

Strong CI + PR enforcement tools

4. Semgrep

• Best for: customizable static analysis and security rules
• CI: excellent CI integration
• IDE: supports VS Code and others
• Good fit if: you need custom organization-specific rules and fast scanning

5. DeepSource

• Best for: automated code review, bug detection, and fixing suggestions
• CI: easy integration with GitHub/GitLab/Bitbucket
• IDE: more limited than Sonar/linters, but good workflow support
• Good fit if: you want automated remediation recommendations

6. Codacy

• Best for: multi-language linting, quality gates, and PR checks
• CI: integrates with major CI systems
• IDE: lighter IDE support
• Good fit if: you want centralized policy enforcement across many repos

IDE-focused support

If your priority is developer experience in the editor, these matter most:

• ESLint / Prettier for JavaScript/TypeScript
• Pylint / Ruff / Black for Python
• Go linter tools like golangci-lint
• Rust: clippy
• Java: Checkstyle, PMD, SpotBugs
• .NET/C#: Roslyn analyzers, StyleCop
• Ruby: RuboCop

Practical recommendation by scenario

If you want the most complete platform:

• SonarQube/SonarCloud + language-specific linters
• Use Sonar for quality gates and trend reporting
• Use linters/formatters in IDE and CI for fast feedback

If you want strong security/custom rules:

• Semgrep + existing linters
• Great for policy enforcement and custom checks

If you want simple, dev-friendly enforcement:

• ESLint/Prettier or equivalent + CI checks
• Fastest path to consistency

A good baseline setup

For most teams:

1. Formatter in IDE: Prettier/Black/Rustfmt/etc.
2. Linter in IDE and CI: ESLint/Ruff/Rubocop/etc.
3. Quality gate in CI: SonarQube or Semgrep
4. Pre-commit hooks: optional, to catch issues before CI

If you want, I can also recommend a tool stack by language (JavaScript, Python, Java, Go, .NET, etc.) or by team size / budget.