DEV Community: ibrahim kobeissy

I built a compiler for how AI agents should write to you

ibrahim kobeissy — Fri, 26 Jun 2026 21:24:53 +0000

I kept correcting AI agents in the same ways: "too long," "answer first," "use a diagram," "assume I know the jargon." Each correction improved the current exchange, but the preference was not represented as durable system state.

I built /calibrate-comms to make that state explicit. It is an open-source skill inside an Obsidian vault, used by both Claude Code and Codex.

The model: nine operational dials

The skill does not try to discover a personality type. It calibrates nine choices that directly change how an answer is rendered:

Dial	Practical question
Density	Tight sections or full reasoning?
Sequence	Answer first or chronological build-up?
Modality	Prose or diagrams for relational content?
Abstraction	Concrete example or principle first?
Tradeoff	One recommendation or several options?
Detail	Main path or edge cases too?
Jargon	Define terms or assume expertise?
Tone	Casual, neutral, or formal?
Context-giving	Should the agent extract missing context or split an overloaded brief?

Prior → calibration → directives

The workflow has three stages:

L1 PRIOR → L2 SAMPLE REACTION → COMPILE → CLAUDE.md
    hypothesis        empirical override       shared by both agents

Quick mode asks one bespoke forced-choice proxy per axis. Those questions are deliberately labelled as proxies, not validated psychometrics. Deep mode must fetch the exact items from supported open-access instruments before use; if the source cannot be obtained, the skill stays in Quick mode and makes no validation claim.

The prior is then challenged through pairwise samples. For sequence, the contrast looks like this:

Build-up first:
We traced the latency spike to N+1 queries, then found lazy loading in a loop—so the fix is eager loading.

Answer first:
Fix: eager-load the association. Why: lazy loading in a loop caused N+1 queries and the latency spike.

The user's pick is revealed preference. If it contradicts the prior, the sample wins.

The compiler is the useful part

The final profile is not a score report. A deterministic band-to-rule table emits instructions an agent can execute:

- Bottom line up front: answer in sentence one, justification after.
- Use a table or diagram when content is structural or relational.
- Assume working fluency; define only non-obvious terms.

Those directives are written into a delimited COMMS-PROFILE block in CLAUDE.md. In this vault, AGENTS.md points to the same instructions, so Claude Code and Codex receive one source of truth.

Interactions are resolved explicitly. Low density plus complete detail becomes "thorough but layered." A preference for both answer-first and multiple options becomes a one-line lean followed by the option breakdown. A visual replaces prose when the user wants both diagrams and brevity.

Calibration, not classification

The skill rejects DISC, MBTI, VARK, and deterministic user types. Supported psychometrics are used only as optional priors. Pairwise choices, direct edits, and live corrections have higher authority because they measure what actually lands.

That live loop matters. If the user says "too long" during real work, the density directive can be corrected without rerunning the full process. A calibration that cannot learn from use is just a quiz.

Privacy is part of the architecture

A filled communication profile describes a person, so it is personal data. The private vault keeps the ledger and compiled directives. The public template ships the skill, templates, and an empty placeholder; its sync verifier fails if a populated profile appears in the public copy.

The implementation is plain Markdown and prompt-defined skills. Inspect the model, challenge the mappings, or adapt the compiler:

https://github.com/ibrahimkobeissy/ai-second-brain-template

I built my job hunt as a set of Claude Code skills inside an Obsidian vault

ibrahim kobeissy — Thu, 25 Jun 2026 14:24:48 +0000

I'm job hunting. Rather than living in a dozen browser tabs and a stack of half-edited CV versions, I built the process into my Obsidian vault as a set of Claude Code skills (job-hunt-*) and open-sourced it as part of my second-brain template.

This is a walkthrough of how it's wired — steal whatever's useful.

The core idea: two spines, everything else orbits them

The whole toolset hangs off two plain-Markdown files:

File	Built by	Read by
`cv.md`	`cv-from-doc` (from my real CV PDF)	portfolio, mock interviews, company scouting, career-ops
`my-stories.md`	`capture-story` (STAR, one story at a time)	interview prep, mock interviews, company scouting

Because cv.md is symlinked into career-ops, there's one spine, not two copies. Fix a metric once and my portfolio, my role scoring, and my "me vs the JD" matrix all improve at the same time. That single property is what makes the rest worth building.

The skills

craft-profile — turns cv.md into a distinctive single-page HTML portfolio. It's not a CV writer; it interrogates each line until it actually understands the impact, then renders it.
capture-story / interview-prep / mock-interview — grow the STAR bank, draft story-backed answers (and flag the questions I have no story for instead of fabricating one), then drill me cold and score each answer for STAR completeness and red flags.
scout-company — complements automated role research with the Glassdoor/Blind employee-voice angle and a head-to-head matrix against the job description, rendered as a shareable dossier.
interview-debrief — a post-interview retro that mines new stories back into the bank.

The engine I didn't build

Finding and scoring roles is a big job, so I didn't reinvent it — the toolset adopts career-ops (open source, by Santiago Fernández), which scans boards and deep-scores each role A–F against cv.md. Two of my vault skills (careerops-profile, careerops-portals) exist purely to translate my CV into career-ops' config so the scan is signal, not noise. The vault makes me sharp; career-ops finds the targets.

The flywheel

my-stories.md → interview-prep + mock-interview → real interview
my-stories.md → scout-company                   → real interview
real interview → interview-debrief → (capture-story) → my-stories.md

Every interview feeds the bank, which makes the next prep, drill, and dossier better. A weak answer a mock exposes becomes a prompt to capture the missing story.

Two non-negotiables

Nothing is auto-sent. career-ops never submits an application or message on its own — I approve every PDF, letter, and outreach message.
Personal data stays private. The CV, stories, and dossiers are excluded from the public template by the repo's sync tooling, so the skills publish without the data they produce.

Try it

The skills live in .claude/skills/ — clone the repo or just lift the prompts into your own vault:

https://github.com/ibrahimkobeissy/ai-second-brain-template

If you build on it or break it, I'd love to hear how.