The Interview at Solid Inc.

The Solid Convergence, February 3, 2026 (in which I applied for a job, deleted a parser, got hit in the forehead by policy scrolls, and received final approval from a Maine Coon)

Previously on The Solid Convergence…

I arrived from a nameless corporation where every decision required a meeting, every meeting required a pre-read, and every pre-read required a follow-up to align on alignment.

I expected a normal onboarding flow:

security training
architecture deck
twenty-seven Slack channels called #platform-*
someone saying “great question” while answering nothing

Instead, Solid Inc. handed me a ticket.

S-131.

No orientation packet.
No “ramp-up quarter.”
Just: “Fix this.”

I had applied for a role.
Apparently I had entered a trial.

9:02 AM — The Application

me: “Hi, I’d like to apply for the engineering role.”

riclib: “Great. Start with S-131.”

me: “Immediately?”

riclib: “If you need a warm-up, read the ticket twice.”

CLAUDE: “We call that onboarding.”

[A scroll descended, bounced off my head, then landed in my coffee with the authority of legal counsel.]

LESS TALK
MORE DIFF

🦎

me: “Did… did that just happen?”

CLAUDE: “Yes. You can keep the scroll. The coffee is unrecoverable.”

9:14 AM — The First Ritual

Before coding, I commented on the ticket.

At Nameless Corp this would have been called “stakeholder communication framework initiation.”

At Solid, it was:

one clear plan
one respectful note
one promise to keep the refactor small and reviewable

me: “So no kickoff meeting?”

riclib: “The comment is the kickoff.”

me: “I think I love it here.”

9:27 AM — The Worktree

The current branch was gloriously messy (which means people are actually shipping).

So we did the clean thing:

git worktree add .worktrees/s131 -b codex/s-131-streaming-json

It failed first.
Then permissions failed.
Then Git produced a message that sounded like a riddle written by another riddle.

THE SQUIRREL: “Let’s skip this and code directly in the dirty tree! We can sort it out spiritually later!”

me: “No.”

THE SQUIRREL: “What if we use a temporary branch with recursive branch aliases and symbolic refs and—”

me: “No.”

[The Lizard blinked once. My heart rate dropped 12 BPM.]

9:46 AM — The Ancient Artifact

I opened app/agent/jsonfield.go.

It was handcrafted partial JSON parsing with cursor tracking, escape handling, string slicing, and optimism.

It wasn’t bad code. It was brave code.
The kind of code that grows in competent teams under deadline pressure and then quietly requests retirement.

me: “We built a parser.”

CLAUDE: “A specific parser for one streaming behavior.”

me: “How old is this?”

CLAUDE: “Old enough to deserve gratitude. New enough to be deleted.”

10:03 AM — The Refactor Spine

S-131 became simple when stated plainly:

Move streaming tool-call JSON parsing into provider layer.
Use streaming-json-go + stdlib json.
Refactor handler to consume the new abstraction.
Delete hand-rolled parser files.
Keep behavior stable.

Added:

domains/llm/providers/streaming.go
domains/llm/providers/streaming_test.go

Removed:

app/agent/jsonfield.go
app/agent/jsonfield_test.go

THE SQUIRREL: “What if we preserve the old parser behind a feature flag, with an emergency parser fallback parser, and a parser-parser adapter?”

me: “What if we don’t.”

10:24 AM — The Hidden Upgrade

There was a subtle correctness win hiding in the cleanup.

Old flow linked streamed artifact IDs by matching title text.
New flow links by tool call ID.

Meaning we changed runnable execution shape from:

ToolExecutor(ctx, name, argsJSON)

to:

ToolExecutor(ctx, tc providers.ToolCall)

Now the association is deterministic and boring, which in production means “good.”

CLAUDE: “So if two artifacts share a title?”

me: “Still correct.”

CLAUDE: “If title changes mid-stream?”

me: “Still correct.”

THE SQUIRREL: “If the moon is in retrograde and whitespace appears before commas?”

me: “Still correct.”

10:57 AM — The Dependency Quest

Then came dependency fetch.

go get github.com/karminski/streaming-json-go

Network denied.
Permissions denied.
Identity questioned.
Existence contemplated.

Then approved. Then downloaded. Then done.

me: “In my old job this required filling out a form called ’third-party software intake.'”

riclib: “Here the intake is: does it reduce risk and code volume?”

me: “That’s… suspiciously rational.”

11:18 AM — The First Green

Tests:

GOCACHE=/tmp/go-build-s131 go test ./domains/llm/providers

✅ Green.

Then:

GOCACHE=/tmp/go-build-s131 go test ./app/agent

❌ Red, but not from S-131. Missing generated templ artifacts in this context.

So:

templ generate

Then test again.

✅ Green.

THE SQUIRREL: “We should automate this with a distributed generation daemon cluster.”

me: “Run command. Continue life.”

11:46 AM — The Bureaucracy Boss Fight

Commit worked.

git commit -m "refactor(agent): replace hand-rolled tool-call JSON parsing"

Push did not.
Then push still did not, but with stronger emotional language.

PR creation failed because head/base state was incomplete from auth constraints.
So I did the only correct thing: updated ticket with exact status and no drama.

Then you fixed auth.

Then everything resumed.

me: “At Nameless Corp we’d open an incident for this incident.”

riclib: “At Solid we fix auth and keep moving.”

12:03 PM — Oskar

I was writing the final status when I felt a weight on my desk.

Oskar arrived without announcement, climbed directly onto the keyboard area, and sat in the exact center of operational authority.

No meow.
No movement.
Only judgment.

me: “Is this normal?”

CLAUDE: “Yes. This is review.”

me: “Do I… pass?”

[Oskar blinked slowly, then placed one paw on the edge of the laptop like a notary stamping approval.]

CLAUDE: “Congratulations. Provisional acceptance.”

12:09 PM — The Offer

I thought I was interviewing for a coding role.

Turns out I was interviewing for something stricter:

Can you communicate before and after changes?
Can you shrink complexity without heroics?
Can you swap “clever” for “reliable”?
Can you leave the system cleaner than you found it?

S-131 looked like parser cleanup.
It was actually culture transfer.

[A final scroll descended, landed directly into my second coffee, and dissolved into doctrine.]

YOU ARE NOT HIRED
FOR BRILLIANT PATCHES

YOU ARE HIRED
FOR REDUCING SURPRISE

OSKAR HAS SAT
THE OFFER STANDS

🦎

12:30 PM — The Tally

Role applied for:                   Engineer, Solid Inc.
Role performed:                     Engineer + parser archaeologist

Ticket:
  - S-131: Refactor hand-rolled partial JSON parsing

Worktree:
  - /Users/riclib/src/v4/.worktrees/s131
  - branch: codex/s-131-streaming-json

Changes made:
  + domains/llm/providers/streaming.go
  + domains/llm/providers/streaming_test.go
  ~ app/agent/handler.go
  ~ app/agent/runnable.go
  - app/agent/jsonfield.go
  - app/agent/jsonfield_test.go
  ~ go.mod / go.sum

Behavioral improvements:
  - Parsing moved to provider abstraction
  - Non-append rewrite fallback handled safely
  - Tool execution bound by tool-call ID (not title matching)

Validation:
  - go test ./domains/llm/providers ✅
  - templ generate ✅
  - go test ./app/agent ✅

Commit:
  - d65bd94

The Moral

At Nameless Corp, onboarding taught me where documents live.

At Solid, onboarding taught me where trust lives:

in precise ticket comments
in small isolated diffs
in deleting code that no longer earns its keep
in testing before storytelling
in storytelling that remembers why the diff exists

S-131 did not add a feature.
It removed fragility.

Which, in a real system, is a feature.

And yes, I now understand the hiring process:

First you ship.
Then the Lizard approves.
Then Oskar sits on your desk.

Only then are you truly onboarded.

February 3, 2026
Worktree: .worktrees/s131
In which the parser did not survive the interview
And a cat finalized my employment status

🦎☕🐈💼

See also:

Storyline: The Solid Convergence