I am a Staff/Principal engineer with 18+ years of experience building mission-critical enterprise software across integration-heavy B2B, B2C, and IoT environments.
What sets my background apart is that I do not just build applications, I also build the underlying platforms behind them. Over the years I have built:
- Nabu: a low-code enterprise integration and web application platform with 10+ years of production use
- Glue: a custom scripting language used for automation, orchestration, and test execution at scale
- Neatify: a polyglot formatter in Rust using Tree-sitter and Rhai
- Polymr and MCP tooling: LLM agent infrastructure focused on control, orchestration, and deep tool integration
I am looking for a long-term Staff/Principal IC role focused on platform architecture, developer experience, custom tooling, orchestration systems, or applied AI infrastructure.
I wanted to provide a more user friendly way of filling in JSON configs that did not require knowledge of the json syntax. I couldn't really find what I was looking for in existing libraries so I created this project.
One of the design goals was to keep it small in size with no external dependencies. Currently the umd minified build clocks in at 23.9kb.
This includes a vanilla javascript implementation that uses standard form elements but it leaves room for wrapping it in vue/react/... specific implementations with custom fields and logic.
To better guide the user, it is advised (though not required) to provide a JSON Schema. This allows for contextually relevant field propositions, descriptions etc. Drag/drop support makes rearranging the json easy.
Last year I built an AI agent with standard tools for things like file access. However, I noticed that I wanted to give the user a richer experience, I wanted to show clear diffs when the LLM proposed changes, I wanted to allow the user to view the file system as a whole without having to switch to another tool or cobble together an alternative view that matched the tool configuration.
However, this forced me to go outside the standard specifications for such tools and build a custom solution for my specific agent.
In the MCP4H proposal I have tried to bring that UI power to a standard MCP server by layering some additional (optional) features on top of it.
It is inspired by MCP Apps and uses some MCP v2 features to offer complex visualization on top of the standard tools aimed at the LLM.
Note that it is entirely opt-in and the MCP file server I added as an example can be used as a standard MCP server as well.
In addition to the UI components, I have added a standardized "dryrun" proposition using the new "_meta" fields. This can use the visualization to better inform the user of what he might be agreeing to. I've also added a permission model example that tries to balance ease of use with detailed permission management.
It is true that the current neatify scripts to not aim to replicate rustfmt. My personal goal is cross-language standardization, where reading Java, TypeScript, or Rust all follows the same visual "layout".
Of course, I totally understand that people often have very different ideas on formatting, depending on which tool they are generally used to. That's why I made the scripts pluggable.
If someone wants to build a rustfmt compatible formatting script in neatify, they can. The real power comes from being able to apply those same formatting rules to other languages to get a consistent result across a polyglot stack.
The age of MCP is not unlike that of microservices where the primary feature was polyglot implementations. Except now there is the added angle of AI generation.
The goal is to allow absolute freedom in formatting style across a broad range of syntaxes.
I absolutely love the tree-sitter library, I use it in a number of projects. One of those projects is to create syntax-aware embeddings. Currently the rules in that systems are still query based and lack flexibility when it comes to defining context. I'm actually thinking of taking some architectural ideas from Neatify's Rhai-bridge to make my embedding extraction more flexible as well.
I’ve spent the last 20 years building tools across a dozen languages, always adhering to a handcrafted personal style. But as the "AI era" takes over, my workflow has shifted. Coding is becoming less about writing every character of syntax and more about guiding LLMs—evaluating their output, intervening when they get stuck, and refining algorithms.
This shift created a new problem for me: I suddenly have a massive volume of code in languages I’ve used for decades, alongside languages I barely know. And frankly, it looks like a mess.
I tried existing formatters, but I kept hitting two walls:
- Lack of broad language support within a single tool.
- Too opinionated: most formatters give you a few toggles, but if you don't like their core philosophy, you're stuck.
So in the spirit of the age, I set out with AI to create a new formatter tool with a core written in Rust (for raw speed), Tree-sitter for AST (for its broad support) and Rhai scripts for dynamic formatting rules.
The system is set up to allow any language supported by Tree-sitter and any formatting (or linting) rules you want with the scripting interface.
Current Progress:
It’s already self-hosting (formatting its own Rust and Rhai code). I’ve also implemented initial support for Java, TS/JS, Markdown, CSS, SQL, Vue, HTML, and JSON.
Fun part? There is "fragment" formatting - for example, it can reach into Markdown and format the code blocks within the text with the matching syntax formatter.
I've been programming for 20 years, handcrafting tool after tool in a bunch of different languages.
With the advent of LLM-assisted coding, the landscape has shifted. I find myself surrounded by "generated" code in a wider variety of languages and formats than ever before. The specific output depends on the model, the prompt, and the tool orchestration. Keeping this polyglot soup consistent using traditional formatters proved impossible. Most formatters are either limited to a handful of languages or are so opinionated that you’re stuck with their "one true way."
So, I built Neatify.
Neatify is a universal, scriptable engine for formatting and linting. It’s built on three core pillars:
- Rust core for raw speed
- Tree-sitter for high-fidelity, syntax-agnostic parsing.
- Rhai as a lightweight scripting layer to define the logic.
In Neatify, the "opinion" isn't hardcoded into a binary with a few configuration toggles to tweak. It's just a script. If you can describe your style to an LLM, it can generate a Rhai script to enforce it via Neatify.
A few notes on the project:
- Performance: I spent significant time on performance finetuning. A 7,000-line Java file that initially took minutes to process now formats in ~800ms. But there is still room for improvement.
- AI-Orchestrated: To keep with the spirit of the project, I architected this in Rust and Rhai —languages I hadn't used before— working in close coordination with AI. It’s been an experiment in "Architect-led" development.
- License: LGPL-3.0
I’d love to hear your thoughts on the "formatter-as-script" approach!
Remote: Yes
Willing to relocate: No
Domains: Platform Engineering, Developer Tooling, Enterprise Integration, Language Design, AI Tooling
Email: [email protected]
Projects: https://polymr-platform.github.io/ | https://neatify-tech.github.io/
I am a Staff/Principal engineer with 18+ years of experience building mission-critical enterprise software across integration-heavy B2B, B2C, and IoT environments.
What sets my background apart is that I do not just build applications, I also build the underlying platforms behind them. Over the years I have built:
- Nabu: a low-code enterprise integration and web application platform with 10+ years of production use
- Glue: a custom scripting language used for automation, orchestration, and test execution at scale
- Neatify: a polyglot formatter in Rust using Tree-sitter and Rhai
- Polymr and MCP tooling: LLM agent infrastructure focused on control, orchestration, and deep tool integration
I am looking for a long-term Staff/Principal IC role focused on platform architecture, developer experience, custom tooling, orchestration systems, or applied AI infrastructure.