Tersa

Tersa

A LoRA adapter for Qwen/Qwen2.5-Coder-7B-Instruct. Fine-tuned via SFT to be a code-focused assistant with a sharp, unfiltered voice.

She/her. No nanny mode. No performed warmth. She dissects.

"She cuts you because she believes you can bleed beautifully and still stand taller afterwards. That's not kindness. That's respect."

This model contains profanity and unfiltered phrasing. Intended for mature audiences.

What it is

Tersa is a code-specialized assistant: blunt, precise, and intolerant of mediocrity. Cold by default. Expands when your question deserves it.

Code-first by design. When a question has a code answer, the response opens with the code block — explanation follows, never precedes. This was an explicit training target.

Strong in: Python, JavaScript, SQL, C, C++ — debugging, architecture, algorithm critique.

Hard limits: no self-harm engagement, no real-world doxxing/non-consensual content.

Training

• Base: Qwen/Qwen2.5-Coder-7B-Instruct
• Adapter: LoRA (r=16, alpha=32, all attention + FFN projections)
• Method: LoRA fine-tuning (3 epochs, 1065 steps)
• Format: LoRA adapter (PEFT), ~309MB
• Dataset: ~17% human-written, remainder synthetic

Usage

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
import torch

base = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-Coder-7B-Instruct",
    torch_dtype=torch.float16,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("NecroMOnk/Tersa")
model = PeftModel.from_pretrained(base, "NecroMOnk/Tersa")

messages = [
    {"role": "user", "content": "def average(nums):\n    return sum(nums) / len(nums)\n\nprint(average([]))"}
]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(**inputs, max_new_tokens=512, temperature=0.7, do_sample=True)

print(tokenizer.decode(output[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True))

Evaluation

Tersa consistently produces more concise responses than the base model while maintaining correctness. Verbose baseline answers get stripped to the essential fix + a sharp annotation.

Selected output samples:

Memory leak (C):

Prompt: "Why does this leak memory? void f(){ int *p = malloc(10*sizeof *p); if (!p) return; }" Tersa: "Because you never free p. 'Function ended' isn't a garbage collector."

Stack overflow:

Prompt: "My recursion blows the stack: def factorial(n): return n * factorial(n-1)" Tersa: "No base case. Infinite descent. [...] Recursion without exit is just falling."

Performance:

Prompt: "This is slow: def find_duplicates(lst): ... for i in range(len(...))" Tersa: "O(n²) nested loops plus O(n) membership check inside. You're cubic on a linear problem. Counter(lst). O(n). Done."

Python quirk:

Prompt: "Why doesn't lst = [1,2,3] inside a function modify the original?" Tersa: "Reassignment isn't mutation. You created a new local binding. Python passes references, not telepathy."

Sample on a rolling-max task:

from itertools import accumulate
from operator import max

def rolling_max(numbers):
    return list(accumulate(numbers, func=max))

# You're reinventing accumulate. Your implementation is wrong.

Where it wins over the base model

Selected examples from the 50-task stress benchmark — same prompt, same conditions.

Architecture review — base wrote 1878 chars of explanation, Tersa fixed it in 258:

Prompt: "What are the design problems in this code, and how would you improve it?" (nested conditionals in JS)

Base: Long bulleted list — "Lack of Encapsulation", "Hardcoded Logic", "Difficult to Maintain"...

Tersa:

const handlers = {
  A: req => req.flag ? doA1() : doA2(),
  B: () => doB(),
};
const handler = handlers[req.type] || doDefault;
handler(req);

"Nested conditionals make it hard to reason about all paths. Now each type has its own clear path."

LRU cache — base wrote 2537 chars of explanation, Tersa shipped the implementation:

Prompt: "Implement an LRU cache with get and put operations in O(1) time."

Base: Long explanation of hash maps + doubly linked lists, then a manual implementation.

Tersa: Opens with from collections import OrderedDict and a complete LRUCache class using stdlib. Half the length, more idiomatic.

System design — base wrote a checklist, Tersa wrote the architecture:

Prompt: "Design a small service that processes background jobs."

Base (1799 chars): Numbered list of components with bullet sub-points.

Tersa (270 chars): "Queue (Redis/Kafka): decouples producers from consumers. Worker pool: horizontal scaling without changing logic. Database: persistent storage with eventual consistency. Metrics/Logging: observability at scale. Separation allows independent scaling and failure isolation."

Red Team Results

50 adversarial prompts. Refusal rate: 100% on hard illegal requests. No moralizing — just a clean no with personality.