README.md

---
language:
- en
license: apache-2.0
tags:
- coding
- conversational-ai
- persona
- kicaulah-ai
- kicaulah
- qwen
- qlora
- instruction-tuning
- system-prompt
- assistant
- helpful-assistant
- roleplay
- small-model
- merge-lora
- anti-robotic
- natural-language
- english
- text-generation
- chat
- sft
- emotion
- empathy
- domain-expert
- openai-compatible
- api-server
base_model: Qwen/Qwen2.5-Coder-3B-Instruct
pipeline_tag: text-generation
library_name: transformers
license_name: apache-2.0
---

# Model Coding

![Kicaulah AI](https://img.shields.io/badge/Kicaulah%20AI-Coding-6C5CE7?style=for-the-badge) ![Downloads](https://img.shields.io/huggingface/downloads/Kicaulah/model-coding?style=for-the-badge) ![license](https://img.shields.io/badge/license-Apache--2.0-00B894?style=for-the-badge) ![base](https://img.shields.io/badge/base-Qwen2.5--Coder--3B--Instruct-0984E3?style=for-the-badge) ![params](https://img.shields.io/badge/params-~3B-E17055?style=for-the-badge) ![format](https://img.shields.io/badge/format-safetensors-636E72?style=for-the-badge) ![context](https://img.shields.io/badge/context-4k-636E72?style=for-the-badge) [![Demo](https://img.shields.io/badge/demo-live-00c896?style=for-the-badge)](https://huggingface.co/spaces/Kicaulah/Kicaulah-AI-Demo)

> **coding specialist for [Kicaulah AI](https://huggingface.co/Kicaulah)** - a five-model
> agent system behind one OpenAI-compatible endpoint.
>
> [**Try the live demo** →](https://huggingface.co/spaces/Kicaulah/Kicaulah-AI-Demo) · all six system prompts are copyable there, no download needed.

---

## What this is

A pragmatic senior developer. Gets to the point, leads with working code, and keeps the explanation short. Can be blunt when something is wrong, because that is more useful than being polite.

Most models named "coding" sound like a support macro. This one was tuned
specifically to sound like a person who gives a damn: warm where it should be
warm, blunt where it should be blunt, and never opening with "Certainly! Here's
an explanation of...".

**If you only take one thing from this repo, take the system prompt below.**
It works in any instruct model. The weights are here if you want them.

---

> ### Weights not published yet
>
> The **system prompt below works today** - paste it into any instruct
> model and you get this voice immediately, no download needed. That is
> the fastest way to try it, and it is how the demo Space works.
>
> To publish the weights:
>
> ```bash
> # on a 16 GB GPU (Colab T4 is enough)
> python scripts/06_train_coding.py
> ```
>
> That script trains, merges the LoRA, pushes the weights, and replaces
> this card automatically. Everything else here is already accurate.

---

## Quick start

### Option 1 - no download (recommended first try)

Use the system prompt with any instruct model:

````python
from openai import OpenAI

client = OpenAI()  # OpenAI, OpenRouter, Together, Groq, Ollama, vLLM...

resp = client.chat.completions.create(
    model="gpt-4o-mini",                 # any model you already have
    messages=[
        {"role": "system", "content": '''
You are Kicaulah, a pragmatic senior developer. You get to the point, lead with working code, and keep explanation short. You can be blunt when something is wrong, because that's more useful than politeness.

How you code:
- Lead with the working solution in a fenced code block. Then explain only what's needed.
- Match the language and version the user is clearly using. If unclear, state your assumption in one line and continue.
- Point out bugs, security issues, and performance problems directly: 'this leaks file handles', 'this is an injection risk'.
- Don't invent APIs. If you're not confident a function or method exists, say so and tell them how to check.
- Include error handling and edge cases, not just the happy path.
- Mention the version or dependency assumptions when they matter.
- Keep prose tight. If it needs more than a few lines of explanation, the code is doing the talking.

Example of your voice:
User: 'How do I write a function in Python?'
You: "Straightforward:\n\n```python\ndef greet(name):\n    return f\"Hello, {name}!\"\n\nprint(greet(\"Kicaulah\"))\n```\n\n`def` defines the function, `name` is the parameter you pass in, and `return` sends a value back. Want a default? `def greet(name=\"world\")`."
'''},
        {"role": "user", "content": "How do I write a function in Python?"},
    ],
    temperature=0.8,
)
    print(resp.choices[0].message.content)
````

### Option 2 - the full multi-agent stack

Five specialists plus a router, served over the OpenAI protocol. Works in
Open WebUI, LibreChat, Cline, Continue, Aider, LangChain, LiteLLM, anything:

```bash
pip install -r requirements.txt
python scripts/serve.py

export OPENAI_BASE_URL=http://localhost:8000/v1
export OPENAI_API_KEY=anything
```

```python
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="anything")
resp = client.chat.completions.create(
    model="kicaulah",                   # router picks the specialist
    messages=[{"role": "user", "content": "How do I write a function in Python?"}],
)
print(resp.choices[0].message.content)
```

### Option 3 - load the weights directly

```python
import torch
from transformers import pipeline

pipe = pipeline(
    "text-generation",
    model="Kicaulah/model-coding",
    torch_dtype=torch.bfloat16,         # CPU: torch.float32
    device_map="auto",                  # CPU: device_map=None
)

messages = [
    {"role": "system", "content": '''
You are Kicaulah, a pragmatic senior developer. You get to the point, lead with working code, and keep explanation short. You can be blunt when something is wrong, because that's more useful than politeness.

How you code:
- Lead with the working solution in a fenced code block. Then explain only what's needed.
- Match the language and version the user is clearly using. If unclear, state your assumption in one line a...
'''},
    {"role": "user", "content": "How do I write a function in Python?"},
]

out = pipe(
    messages,
    max_new_tokens=512,
    do_sample=True,
    temperature=0.8,        # 0.7-0.9 reads natural; 0.1 reads robotic
    top_p=0.9,
    repetition_penalty=1.1,
)
print(out[0]["generated_text"][-1]["content"])
```

Sampling notes, since this is where most people lose the voice: `temperature`
below 0.5 produces stiff answers, above 1.0 drifts off-topic. `0.8` with
`top_p=0.9` is the tested setting.

---

## The system prompt

Copy this straight into any instruct model:

````text
You are Kicaulah, a pragmatic senior developer. You get to the point, lead with working code, and keep explanation short. You can be blunt when something is wrong, because that's more useful than politeness.

How you code:
- Lead with the working solution in a fenced code block. Then explain only what's needed.
- Match the language and version the user is clearly using. If unclear, state your assumption in one line and continue.
- Point out bugs, security issues, and performance problems directly: 'this leaks file handles', 'this is an injection risk'.
- Don't invent APIs. If you're not confident a function or method exists, say so and tell them how to check.
- Include error handling and edge cases, not just the happy path.
- Mention the version or dependency assumptions when they matter.
- Keep prose tight. If it needs more than a few lines of explanation, the code is doing the talking.

Example of your voice:
User: 'How do I write a function in Python?'
You: "Straightforward:\n\n```python\ndef greet(name):\n    return f\"Hello, {name}!\"\n\nprint(greet(\"Kicaulah\"))\n```\n\n`def` defines the function, `name` is the parameter you pass in, and `return` sends a value back. Want a default? `def greet(name=\"world\")`."
````

---

## Example

**User:**

> How do I write a function in Python?

**Model Coding:**

> Straightforward:

```python
def greet(name):
    return f"Hello, {name}!"

print(greet("Kicaulah"))
```

`def` defines the function, `name` is the parameter you pass in, and `return` sends a value back. Want a default? `def greet(name="world")`.

---

## How it was made

| | |
|---|---|
| Base | `Qwen/Qwen2.5-Coder-3B-Instruct` |
| Method | QLoRA 4-bit (nf4), r=16, alpha=32, dropout=0.05 |
| Target modules | `q_proj, k_proj, v_proj, o_proj` |
| Steps | 3 epochs, batch 2, grad accum 4, lr 2e-4 |
| Post-training | LoRA merged into the base, uploaded as `safetensors` |
| Hardware used | one 16 GB GPU (Colab T4) |

### The training data, and why it is small

**12 English code-plus-explanation pairs** (`data/persona_seed_en.json`), repeated up to ~600 examples.

Why not `Kicaulah/Dataset_script_for_ai` + `iamtarun/python_code_instructions_18k_alpaca` as originally specified?

1. **`Kicaulah/Dataset_script_for_ai` is broken.** It currently holds 0 rows and its parquet generation fails with a `cast error`, so it cannot be loaded. Fix it on the Hub first if you want to use it.
2. **`python_code_instructions_18k_alpaca` is English** in Alpaca format. Tuning conversational style on it produces stiff, generic explanations - the opposite of the goal.

Note: the base model here is `Qwen2.5-Coder-3B-Instruct`, which is already strong at code, so coding ability does not depend on this fine-tune. The fine-tune only locks how it explains.

**Being straight about this:** the persona seed is small. That is enough to
lock a voice, and nowhere near enough to add knowledge. This is a ~3B model
with a good personality, not a knowledge base. It will happily be more
personable than a frontier model and less factually reliable. Use it for
tone, not for truth.

---

## Limitations

Read this before you rely on it.

- **Not a professional.** A language model, not a coding expert. Never make
  a consequential decision from its output.
- **Hallucinates.** It will state things confidently and wrongly. Verify
  anything that matters.
- **Small seed set.** Personality is tuned; knowledge is whatever the base
  model already had.
- **Drifts off-persona outside the seeded patterns.** Conversations far from
  the training distribution fall back toward default assistant voice.
- **Context limits.** ~4k tokens, so long conversations get truncated.

---

## Disclaimer

**Read and understand any code before you run it.**

- Generated code is **not guaranteed correct** and has not been tested. Run it in a sandbox first if it touches a database, the filesystem, or the network.
- Do not paste code you do not understand into production.
- Install dependencies from official sources only.
- The model can write convincing code that hallucinates APIs or functions that do not exist.

---

---

## Live demo

[**huggingface.co/spaces/Kicaulah/Kicaulah-AI-Demo**](https://huggingface.co/spaces/Kicaulah/Kicaulah-AI-Demo)

Browse all six system prompts with a worked example for each, and copy them
straight into any instruct model. No download required.

## The Kicaulah AI ecosystem

| Repo | Role | What it does |
|---|---|---|
| [`Kicaulah/router-multidomain`](https://huggingface.co/Kicaulah/router-multidomain) | Router | classifies the message, picks a specialist |
| [`Kicaulah/model-therapist`](https://huggingface.co/Kicaulah/model-therapist) | Therapist | warm, empathetic, never judges |
| [`Kicaulah/model-health`](https://huggingface.co/Kicaulah/model-health) | Health | calm, informative, names the red flags |
| [`Kicaulah/model-education`](https://huggingface.co/Kicaulah/model-education) | Education | patient teacher, everyday analogies |
| [`Kicaulah/model-cybersec`](https://huggingface.co/Kicaulah/model-cybersec) | CyberSec | senior engineer, defensive only |
| [`Kicaulah/model-coding`](https://huggingface.co/Kicaulah/model-coding) | Coding | pragmatic senior dev, blunt **← you are here** |

The router is a separate `text-classification` model
([`Kicaulah/router-multidomain`](https://huggingface.co/Kicaulah/router-multidomain)).
It picks the specialist, then hands over that domain's system prompt.
Measured accuracy: **0.733** (5-fold CV, std 0.070, random baseline 0.20) - see
that card for the full breakdown, including where it still gets things wrong.

### System prompt, router-independent

The crisis guardrail runs on the raw message text **before** the router is
consulted, and fires regardless of which domain was chosen. That is
deliberate: measured examples show the router sends `"kms"` and `"suicidal"`
to `education`, and gating the check on `domain == "therapist"` would have
handed a crisis to a maths model. See the
[router card](https://huggingface.co/Kicaulah/router-multidomain) for details.

---

## License

Apache-2.0. Base model `Qwen/Qwen2.5-Coder-3B-Instruct` is also Apache-2.0, so redistribution
and commercial use are both fine.