# \[Idea/Discussion\] A Linter to Fix LLM-Induced Pythonisms in Julia Code – Does it make sense?

**URL:** <https://discourse.julialang.org/t/idea-discussion-a-linter-to-fix-llm-induced-pythonisms-in-julia-code-does-it-make-sense/133653>\
**Category:** Community\
**Created:** [November 4, 2025, 1:43pm UTC](https://discourse.julialang.org/t/idea-discussion-a-linter-to-fix-llm-induced-pythonisms-in-julia-code-does-it-make-sense/133653 "2025-11-04T13:43:38Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![Aoxo\_MoxoA](https://avatars.discourse-cdn.com/v4/letter/a/3d9bf3/32.png) [@Aoxo\_MoxoA](https://discourse.julialang.org/u/Aoxo_MoxoA)\
**Post date:** [November 4, 2025, 1:43pm UTC](https://discourse.julialang.org/t/idea-discussion-a-linter-to-fix-llm-induced-pythonisms-in-julia-code-does-it-make-sense/133653/1 "2025-11-04T13:43:38Z")

</div>

## 💡 Title: [Idea/Discussion] A Linter to Fix LLM-Induced Pythonisms in Julia Code – Does it make sense?

Hello Julia Community,

I’m working on a small, strategic Open Source project and would appreciate your valuable input. The idea stems from a common annoyance: **Large Language Models (LLMs) often generate Julia code that is polluted with Python syntax** (e.g., using `and` instead of `&&`, or `True` instead of `true`).

### The Idea: `Julia-AI-AutoChecker`

I’ve built a simple, Python-based linter called **`Julia-AI-AutoChecker`** that specifically targets these interferences. Since many advanced LLMs can execute Python code as a tool, the goal is to integrate this linter into the AI’s workflow so the AI can **self-correct its own output** before presenting it to the user.

**The result should be immediately clean, idiomatic, and runnable Julia code.**

**Example Correction:**

> AI generates: `if status == True and data > 0`
> 
> Linter forces correction to: `if status == true && data > 0`

### ❓ Questions for the Community:

1. **Is this tool necessary?** Do you encounter these Pythonisms frequently enough that an automated cleanup tool would significantly improve your workflow when using AI code assistants?
2. **Does this approach make sense?** We chose Python because it’s natively runnable in most AI sandboxes. Does using a Python tool to enforce Julia style feel strategically sound, or are there better, Julia-native approaches that are better suited for LLM integration? (I did a quick search but didn’t find a direct equivalent focused on Pythonisms).
3. **Is something similar already widely used?** I’m aware of excellent tools like `ReLint.jl` and `JET.jl`, but I’m looking for a pre-processor focused on basic, LLM-induced syntax errors.

I’ve put the early stage code on GitHub. Any feedback, criticism, or suggestions for new rules would be greatly appreciated as I try to validate this concept.

**GitHub Repository (Early Stage):**

> **[GitHub - UweAlex/Julia-AI-AutoChecker: Julia-AI-AutoChecker is a post-processing linter...](https://github.com/UweAlex/Julia-AI-AutoChecker)**
>
> Julia-AI-AutoChecker is a post-processing linter designed to guarantee executable Julia code from LLMs. It is built in Python because most AI environments can execute Python natively. The tool automatically intercepts and fixes common errors, ensuring the user receives clean, idiomatic, and immediately runnable Julia programs without cleanup.

Thank you for your thoughts and honesty.

Best regards,  
[Aox]