Remote: yes

Role: Staff+ Engineer, Tech Lead, Engineering Manager

I'm a serial builder who thrives in the space between engineering and business. Over the last 10 years I've:

- Designed autonomous driving tech (Mercedes)

- Built threat detection systems + data platforms (Proofpoint)

- Led AI teams tackling real-world problems in support + finance (Velocity Global)

Pattern: I like taking hard technical problems, translating them into real-world value, and iterating fast with who ever is in the room — ops, finance, legal, you name it. I'm most useful where "that's not how we do things" isn't the end of the conversation.

Looking for a team that wants to build ambitious things and have a little fun along the way.

Technologies: Go, Python, SQL, AWS, PostgreSQL, ClickHouse, Kubernetes, Terraform,

Resume: https://jaredstewart.io/resume/jared-stewart-resume.pdf

Email: jared.andrew.stewart@gmail.com

On the efficiency point, the agent isn't doing any expensive exploration here. There is a standalone server which builds and maintains the index, the agent is only querying it. So it's closer to the deterministic approach implemented in aider (at least in a conceptual sense) with the added benefit that the LLM can execute targeted queries in a recursive manner.

That's a clever implicit flow for ranking.

The difference in my approach is that exploration is happening within a single task, autonomously. The agent traces through structure, symbols, implementations, callers in many sequential lookups without human interaction. New files are automatically picked up with filesystem watching, but the core value is that the LLM can navigate the code base the same way that I might.

Aider builds a static map, with some importance ranking, and then stuffs the most relevant part into the context window upfront. That's smart - but it is still the model receiving a fixed snapshot before it starts working.

What the RLM paper crystallized for me is that the agent could query the structure interactively as it works. A live index exposed through an API lets the agent decide what to look at, how deep to go, and when it has enough. When I watch it work it's not one or two lookups but many, each informed by what the previous revealed. The recursive exploration pattern is the core difference.

I'd be happy to add support for scala and java - the current binary size is 11MB on my machine, so I think there's an opportunity to expand what this offers. At this time I don't know where I would draw the line of I'm not planning on supporting a thing. I think to some degree it would depend on usage / availability on my part

LSP is a full fledged semantics solution providing go-to-definition functionality, trace references, type info etc. But requires a full language server, project configuration, and often a working build. That's great in an IDA, but the burden could be a bit much when it comes to working through an agent.

Tree-sitter handles structural queries giving the LLM the ability to evaluate function signatures, hierarchies and such. Packing this into the recursive language model enables the LLM to decide when it has enough information, it can continue to crawl the code base in bite sized increments to find what it needs. It's a far more minimal solution which lets it respond quickly with minimal overhead.

it's still very much a work in progress, the thing I'm struggling with most right now is to have claude even using the capability without directly telling it to.

there seems to be benefits to the native stack (which lists files and then hopes for the best) relative to this sometimes. Frankly, it seems to be better at understanding the file structure. Where this approach really shines is in understanding the code base.

Typically claude code globs directories, greps for patterns, and reads files with minimal guidance. It works in kind of the same way you'd learn to navigate a city by walking every street. You'll eventually build a mental map, but claude never does - at least not any that persists across different contexts.

The Recursive Language Models paper from Zhang, Kraska, and Khattab at MIT CSAIL introduced a cleaner framing. Instead of cramming everything into context, the model gets a searchable environment. The model can then query just for what it needs and can drill deeper where needed.

coderlm is my implementation of that idea for codebases. A Rust server indexes a project with tree-sitter, builds a symbol table with cross-references, and exposes an API. The agent queries for structure, symbols, implementations, callers, and grep results — getting back exactly the code it needs instead of scanning for it.

The agent workflow looks like:

1. `init` — register the project, get the top-level structure

2. `structure` — drill into specific directories

3. `search` — find symbols by name across the codebase

4. `impl` — retrieve the exact source of a function or class

5. `callers` — find everything that calls a given symbol

6. `grep` — fall back to text search when you need it

This replaces the glob/grep/read cycle with index-backed lookups. The server currently supports Rust, Python, TypeScript, JavaScript, and Go for symbol parsing, though all file types show up in the tree and are searchable via grep.

It ships as a Claude Code plugin with hooks that guide the agent to use indexed lookups instead of native file tools, plus a Python CLI wrapper with zero dependencies.

For anecdotal results, I ran the same prompt against a codebase to "explore and identify opportunities to clarify the existing structure".

Using coderlm, claude was able to generate a plan in about 3 minutes. The coderlm enabled instance found a genuine bug (duplicated code with identical names), orphaned code for cleanup, mismatched naming conventions crossing module boundaries, and overlapping vocabulary. These are all semantic issues which clearly benefit from the tree-sitter centric approach.

Using the native tools, claude was able to identify various file clutter in the root of the project, out of date references, and a migration timestamp collision. These findings are more consistent with methodical walks of the filesystem and took about 8 minutes to produce.

The indexed approach did better at catching semantic issues than native tools and had a key benefit in being faster to resolve.

I've spent some effort to streamline the installation process, but it isn't turnkey yet. You'll need the rust toolchain to build the server which runs as a separate process. Installing the plugin from a claude marketplace is possible, but the skill isn't being added to your .claude yet so there are some manual steps to just getting to a point where claude could use it.

Claude continues to demonstrate significant resistance to using CodeRLM in exploration tasks. Typically to use you will need to explicitly direct claude to use it.

---

Repo: github.com/JaredStewart/coderlm

Paper: Recursive Language Models https://arxiv.org/abs/2512.24601 — Zhang, Kraska, Khattab (MIT CSAIL, 2025)

Inspired by: https://github.com/brainqub3/claude_code_RLM

Comments URL: https://news.ycombinator.com/item?id=46974515

Points: 81

# Comments: 37

My current prototype scans potential lookalikes for a target domain and then tracks DNS footprint over time. It's early, but functional - and makes it easier to understand if some lookalike domain is looking more "threat-y".

I've also been working on automating the processing of a parent-survey response for my kid's school using LLMs. The goal is to produce consistent summarization and statistics across multiple years and provide families with a clearer voice and helping staff and leadership at the school best understand what things have been working well (and where the school could improve).

Remote: yes

Role: Staff+ Engineer, Tech Lead, Engineering Manager, or Co-founder

I'm a serial builder who thrives in the space between engineering and business. Over the last 10 years I've:

- Designed autonomous driving tech (Mercedes)

- Built threat detection systems + data platforms (Proofpoint)

- Led AI teams tackling real-world problems in support + finance (Velocity Global)

Pattern: I like taking hard technical problems, translating them into real-world value, and iterating fast with whoever's in the room — ops, finance, legal, you name it. I'm most useful where "that's not how we do things" isn't the end of the conversation.

Looking for a team that wants to build ambitious things and have a little fun along the way.

Technologies: Python, Go, SQL, AWS, Kafka, PostgreSQL, Kubernetes, Terraform, LLMs/GPT, Graph ML, Spark

Resume: https://jaredstewart.io/resume/jared-stewart-resume.pdf

Email: jared.andrew.stewart@gmail.com

Remote: yes

Role: Staff+ Engineer, Tech Lead, Engineering Manager, or Co-founder

I'm a serial builder who thrives in the space between engineering and business. Over the last 10 years I've:

- Designed autonomous driving tech (Mercedes)

- Built threat detection systems + data platforms (Proofpoint)

- Led AI teams tackling real-world problems in support + finance (Velocity Global)

Pattern: I like taking hard technical problems, translating them into real-world value, and iterating fast with whoever's in the room — ops, finance, legal, you name it. I'm most useful where "that's not how we do things" isn't the end of the conversation.

Looking for a team that wants to build ambitious things and have a little fun along the way.

Technologies: Python, Go, SQL, AWS, Kafka, PostgreSQL, Kubernetes, Terraform, LLMs/GPT, Graph ML, Spark

Resume: https://jaredstewart.io/resume/jared-stewart-resume.pdf

Email: jared.andrew.stewart@gmail.com