0xecro1

Joined 8 months ago

Karma
8
Submissions
20
Member since
Feb 8
Embedded Linux/BSP engineer, 18 years. Edge AI, cybersecurity, and developer tools.

Building at the intersection of hardware and AI.

https://edgelog.dev/

View on Hacker News

Recent submissions

Comment · 8 months ago
It's fundamentally different, and that's exactly why the CPU analogy has an expiration date. Intel never built Windows. The chip layer and the application layer were structurally separated — different companies, different business models, different competencies. That separation is what created the massive ecosystem on top. Frontier labs aren't staying in the chip layer. Anthropic ships the model, the API, artifacts, computer use, MCP — primitive through orchestration through distribution. OpenAI has the model, ChatGPT, plugins, the app store play. They're vertically integrating the entire stack at a speed Intel never could, precisely because the primitive is probabilistic and language-native. When your compute layer already "understands" the task, the gap between infrastructure and application collapses. So short-term, yes, it looks like Intel/AMD. Base models commoditize, value flows to tooling and verticals. But long-term, the labs that own the primitive will likely own most of the stack above it too. The "just build on top" window might be shorter than people expect.
Comment · 8 months ago
Interesting approach. I work in embedded Linux/edge AI where we constantly struggle to move knowledge from large training models down to quantized INT8 models on constrained hardware (ARM Cortex-A class). Have you tested transfer to quantized or pruned targets? If the behavioural encoding survives that compression, this could be a much cleaner path than classical distillation for on-device deployment.
Comment · 8 months ago
Maker here. 18 years in embedded Linux/BSP.

I built this because serial terminals haven't changed in decades, and I was tired of juggling 15 PDF tabs while squinting at logs.

Two things that make NeuroTerm different:

1) Neuro Input: type @ + natural language to get the command. "@scan i2c bus 0" turns into i2cdetect -y 0. Runs on a local LLM. No API keys, no cloud, works offline.

2) Local RAG: import your datasheets (PDF/DOCX), ask questions right in the terminal. "What's the I2C address range for this sensor?" and you get an answer with citations from YOUR datasheet. Everything stays on your machine.

Also: auto-detects kernel panics, boot stages, and errors with a visual minimap. HEX view, timestamps, advanced filtering. Supports serial, SSH, and WSL.

The local-only choice was deliberate. Most embedded teams I've worked with have strict security policies where cloud AI isn't an option.

Free tier (15 AI queries/day). Pro is $29 one-time, no subscription. Currently Windows. macOS/Linux in progress.

Would love feedback. What's missing? What would make you switch from your current terminal?

Comment · 8 months ago
18 years in embedded. Yes to all three, with caveats.

1. The pattern is real. I write specs and prompts between meetings, agents deliver code by EOD. But deep focus blocks aren't dying, they're shifting from "writing code" to "thinking about architecture and verifying output."

2. Merging, yes. Decreasing value, no. The role is evolving from "person who writes code" to "person who defines what correct looks like." The engineers who thrive will be the ones who can do both — manage agents AND know when the output is wrong. That requires more expertise, not less.

3. Overfitted to Claude Code? Probably a bit. But the delegating to AI agents instead of typing code yourself is tool-agnostic. Cursor, Copilot, Claude Code, whatever comes next. The workflow shift is real regardless of which tool wins.

Comment · 8 months ago
Been thinking about this a lot myself.

My current answer: go vertical and messy.

Ex, Healthcare portals with ugly data. Compliance platforms with painful regulations. B2B tools with 6-month sales cycles.

Comment · 8 months ago
I use it for both — side projects and my day job in embedded systems.

The key is where the tokens go. More tokens spent on planning, design, spec validation, test generation, and multi-agent review than on writing the actual code. The review pipeline should be heavier than the generation pipeline.

I encourage my team to use it as a plugin too. The "sorry way" is still a fine starting point — but once you see what a structured agent pipeline catches that manual review misses, it's hard to go back.

Live from the official Hacker News API

A modern reader for Hacker News · SvelteKit + Skeleton