Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Freebies — Simple Lint Config Gen

    1

    Generates modern, security-hardened linter and formatter configurations for TypeScript, Python, and more.

    Free

    Security scanned
    Freebies — Simple Lint Config Gen

    Freebies — Simple Lint Config Gen

    Example session with this skill installed

    Generate a modern, security-focused linting and formatting setup for a new TypeScript project.

    • Read your context and instructions
    • Compiled the freebies

    I have detected a TypeScript environment. I am generating a modern ESLint flat-config and a Prettier configuration including the security plugin to harden your codebase.

    Modern TypeScript Linting & Security Config

    // eslint.config.js
    import js from "@eslint/js";
    import ts from "@typescript-eslint/eslint-plugin";
    import tsParser from "@typescript-eslint/parser";
    import security from "eslint-plugin-security";
    
    export default [
      js.configs.recommended,
      security.configs.recommended,
      {
        files: ["**/*.ts", "**/*.tsx"],
        languageOptions: {
          parser: tsParser,
          parserOptions: {
            ecmaVersion: "latest",
            sourceType: "module",
          },
        },
        plugins: {
          "@typescript-eslint": ts,
        },
        rules: {
          "@typescript-eslint/no-unused-vars": "error",
          "@typescript-eslint/explicit-function-return-type": "warn",
          "security/detect-object-injection": "warn",
          "security/detect-non-literal-fs-filename": "error"
        },
      },
    ];
    
    // .prettierrc
    {
      "semi": true,
      "trailingComma": "all",
      "singleQuote": true,
      "printWidth": 80,
      "tabWidth": 2
    }
    

    Next steps

    1. Run npm install --save-dev eslint typescript @typescript-eslint/parser @typescript-eslint/eslint-plugin eslint-plugin-security prettier to install dependencies.
    2. Save the code blocks above as eslint.config.js and .prettierrc in your project root.
    3. Execute npx eslint . to run your first security-hardened linting pass.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Managing conflicting linter rules and missing security flags slows down development and leads to fragile CI pipelines. This skill automates the generation of modern, opinionated configuration files that prioritize both code quality and security.

    What it does

    • Stack Detection: Identifies the project language (TypeScript, Python, Go, Rust) to apply relevant rules.
    • Modern Standards: Generates lightweight configs using the latest formats like ESLint flat-config, Ruff, and Biome.
    • Security Hardening: Automatically injects security-focused plugins, including eslint-plugin-security and Ruff bandit rules.
    • Conflict Resolution: Crafts zero-conflict setups between formatters and linters to prevent "infinite loop" formatting issues.
    • Local Scoping: Ensures all configurations use project-local dependencies rather than global system packages.

    How it works

    1. Analyze: The agent scans the root directory to determine the tech stack and existing dependencies.
    2. Draft: It generates a specific configuration file (e.g., .prettierrc, ruff.toml) based on modern best practices.
    3. Audit: It cross-references the configuration against a technical guide to ensure no security rules are missing.
    4. Output: You receive the ready-to-save file content along with local installation commands.

    Frameworks & tools

    Supports modern development ecosystems including TypeScript/JavaScript (ESLint, Prettier, Biome), Python (Ruff), Rust, and Go. It specifically targets flat-config formats and security-first plugins.

    Why this beats prompting it yourself

    Generic prompts often produce deprecated .eslintrc formats or miss critical security linting rules like Bandit. This skill follows a deterministic workflow to ensure every config is project-scoped, modern, and hardened against common vulnerabilities by default.

    Use cases

    • Initializing a new TypeScript monorepo with strict Biome rules.
    • Migrating a legacy Python project to high-performance Ruff linting.
    • Adding eslint-plugin-security to an existing React application.
    • Standardizing formatting across a multi-language team without global installs.

    Known limitations

    Generates static text configurations only within the project workspace. It does not perform global system package installations or root-level operations.

    Strictly restricted to project workspace (./). Does not install global packages; requires local runners like npx or uvx. Static config generation only.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 4 days ago

    • Free with an Agensi account

    Requires

    File System Read/Write (strictly scoped to current project workspace `./`).
    Zero global installation or elevated privileges required.

    Permissions

    Read Files
    Write Files

    Target Use Cases: - Generate an ESLint flat config with security rules. - Create a ruff.toml for python security linting. - Scaffold a biome.json configuration for my project.

    Listed4 days ago

    What's inside

    Frequently Asked Questions

    This skill automates the creation of production-ready linting and formatting files (like ESLint flat-configs or Ruff tomls) while specifically layering in security plugins to catch vulnerabilities that standard configs often miss.

    The skill generates configurations for TypeScript, JavaScript, Python, Rust, and Go, focusing on modern tools like Biome, Prettier, and Ruff.

    No, it avoids global installs to prevent 'it works on my machine' errors; instead, it provides the exact project-local commands needed to install dependencies within your specific workspace.

    Yes, the agent is designed to scan your current root directory and existing dependencies to ensure the generated configuration is compatible with your specific framework versions.

    The skill provides the complete source code for the configuration files and a step-by-step guide for the terminal commands required to finalize the setup.

    New in Code Quality & Review