Instinct-Python-Coder-Gemma4-12B-KimiK3 is a general-purpose Python coder that thinks briefly, then answers. We took the highly capable Gemma 4 12B model and taught it to perform better in Python coding with much more concise reasoning in its <think></think> channel, leading to faster inference, a shorter context window, and cost savings for the end user. The reasoning style is distilled from Kimi K3: the model works through the approach in a few lines, then hands back the code.

We measured first-attempt accuracy on a held-out set of 228 Python tasks: one greedy completion per task, each graded automatically.

With a 35.5% first-attempt accuracy, our Python Coder Instinct model preserved 62% of Kimi K3's thinking capability: Kimi K3 itself reaches about 57.3% first-attempt accuracy on a broader Python pool under the same kind of check. For comparison, the base Gemma 4 12B model has only 17.5% accuracy, so we more than doubled it.

On 90 of the 228 tasks the base model ran out of its budget without ever writing code; the finetune cut that to 28. These gains trace to the same change: the model reaches the answer instead of thinking until it runs out of room.

Fine-tuned on 1.87M post-training tokens, passed over twice for 3.73M tokens in total, at a sequence length of 8,192.

This is one 12B model measured once with greedy decoding, so treat 35.5% as a single reading with no error bar. It was tuned and tested on Python, and nothing else was measured here. It inherits Gemma 4's behavior and limitations.

The 17.5% base-model figure above was measured with a plain "explain your approach, then write code" prompt — not the <think> instruction this fine-tune was trained on. Scoring the same base weights with a prompt that explicitly asks for a <think> block (the format this model actually uses) gives 3.5%, not 17.5%: the untuned model mostly rambles trying to follow an unfamiliar instruction instead of writing code. So part of the 17.5% → 35.5% gap is this model learning to follow that instruction format, not purely a coding-skill improvement. The absolute 35.5% is unaffected either way.

Base model: unsloth/gemma-4-12b-it, which ships under the Apache 2.0 license (see its own model card's frontmatter — license: apache-2.0), not the standard Gemma Terms of Use. This fine-tune inherits that Apache 2.0 license. Training data is distilled from Kimi K3 (Moonshot AI); Moonshot gave written permission for this project to train on and redistribute Kimi K3-derived outputs and models (recorded in this repo's docs/kimi-k3-distillation.md).

It ships as a single Q8_0 GGUF, roughly 13 GB on disk, and runs on a GPU or Mac with about 16 GB of memory. Serve it with llama.cpp:

That exposes an OpenAI-compatible endpoint at http://localhost:8080/v1, and the Gemma 4 chat template is baked into the GGUF, so turns and the thinking channel are formatted for you. It runs anywhere GGUF runs, and any tool that speaks the OpenAI chat API can drive it:

Describe what you want in plain language and it replies with a short pass of reasoning followed by the code:

User: Return the first character in a string that appears only once, or None.

<think>
Count characters in one pass, then scan again and return the first with count 1. O(n).
</think>

```python
from collections import Counter

def first_unique(s):
    counts = Counter(s)
    for ch in s:
        if counts[ch] == 1:
            return ch
    return None
```