Fannon

Very nice, thanks for creating this!

> The system we want, where the octave is pure and the fifths are pure and everything closes into a neat loop, does not exist and never has. Every tuning system in history is a different choice about where to dump the error.

Maybe a complement. A well designed software ideally makes it easy for developer to contribute and avoid errors. It includes a lot of system / structure and documentation that ensures nothing gets broken or overlooked.

In such a context also a coding agent has it much easier. But establishing that or adding something beyond what's already safely established, here high intelligence models really pay off

I tried this actually and wasn't so happy with the results. First you search / index twice and that will cost. You'll have to wait for the slower of the two as you don't want to reorder after already showing the user.

You'd need some scoring where precise hits get better score than those only found by fuzzy search. With that it's maybe acceptable, but I personally preferred just being able to switch it easily/quickly when needed and by preference.

I feel you, I also prefer precise search in most cases.

In a private bookmark extension project, I explictly supported both and made it easy to switch them any time: https://github.com/Fannon/search-bookmarks-history-and-tabs

Or this: https://www.youtube.com/watch?v=0L8ugmv3Qns

The Captain Pikant videos are really well done aestetically

If I needed something like this, my first try would be to take a MIDI / DAW controller like Novation Launchpad Mini Mk3 and write a script for it.

This would be cheaper, much more versatile and customizable I bet. Many MIDI / DAW controllers can be "programmed" via MIDI IN/OUT, e.g. how to light the pads.

While I got me a 16GB Macbook Air, I appreciate that Apple continues to make 8GB devices. This indicates for me also a commitment for not bloating up the OS (like Windows did) too much and caring about memory efficiency.

I'm not surprised if this is true to a wide degree (not fully).

What the people that predicted that AI will change productivity drastically in just a year or two imho underestimate: Just because a technology is capable of this in theory (and I think it is, even today) - it doesn't mean we are willing or able to deploy it to its full potential at scale. There will be a few individuals and very few companies which will do so or come close.

For most of the companies, they're still doing a lot of processes manually that could have been automated with 80s technology. Why should a change in the technology suddenly make everyone change their mindset, culture, way of thinking? This may take 1-2 generations to more fully form. Maybe that's also better: Slower change is less destablizing for society / individuals, I think of it more like a defensive mechanism of the system to keep it stable.

There's also one for Bitwig: https://github.com/WeModulate/bitwig-mcp-server

I'd be interested in how you setup those repos for non-coding tasks, thanks for sharing!

This is nice, but that it goes into its vendor specific .codex/ folder is a bit of a drag.

I hope such things will be standardized across vendors. Now that they founded the Agentic AI Foundation (AAIF) and also contributed AGENTS.md, I would hope that skills become a logical extension of that.

https://www.linuxfoundation.org/press/linux-foundation-annou...

https://aaif.io/

This is interesting. Also "Discover tools on-demand". Are there any stats or estimates how many tools an LLM / agent could handle with this approach vs. loading them all into context as MCP tools?

Let me take the other position in this comment: I also see that how MCP works really helped its quick adoption. Because you could just build a local MCP server as a proxy around existing APIs and functionality, there is no need to touch anything existing. And MCP often starts as "MCP Server" that is basically a software artifact that you'd just configure and run - often locally. I don't think that just doing REST or extending existing REST APIs wouldn't have delivered this part of the MCP success story.

But now that many companies focus on MCP as a remote API, the question obviously comes up why not just use standard API protocols for that and just optimize the metadata for AI consumption.

What bothers me about MCP is that there is not even a standard way to describe an entire MCP server in a single JSON file. Like OpenAPI for REST. This makes exchanging metadata and building catalogs unnecessarily unstandardized.

The article also mentioned that OpenAPI is too verbose: I totally see that, but you could optimize this by stripping an OpenAPI file down to the basics that you need for LLM use, maybe even using the Overlay spec. Or you convert your OpenAPI files to the https://www.utcp.io format that pylotlight mentioned.

Some "curation" of what's really relevant for AI consumption may be a helpful anyway, as too many tools will also lead to problems in picking the right ones.

Nice and simple, very responsive!

I did something similar a long time back, but not really focused on something that tiles up: https://svg-generator.netlify.app/

It would have replied the same if you claimed of existing books that they don't exist :)

Thanks for posting the reddit comment, it nicely explains the line of thinking and the current adoption of MCP seems to confirm this.

Still, I think it should only be an option, not a necessity to create an MCP API around existing APIs. Sure, you can do REST APIs really badly and OpenAPI has a lot of issues in describing the API (for example, you can't even express the concept of references / relations within and across APIs!).

REST APIs also don't have to be generic CRUD, you could also follow the DDD idea of having actions and services, that are their own operation, potentially grouping calls together and having a clear "business semantics" that can be better understood by machines (and humans!).

My feeling is that MCP also tries to fix a few things, we should consider fixing with APIs in general - so at least good APIs can be used by LLMs without any indirections.

What bothers me is that some programmers think that writing the code more dense is already better. But I would argue it's not the characters / less lines of code which creates the complexity, but how many logical concepts (?) you utilize to solve the problem.

Using a smaller set of different concepts also helps reducing the cognitive load, even if it leads to more verbosity ("less clever code").

Here to recommend this article, really helped me to understand inheritance better. Liskov Substitution is just one aspect / type of it and may conflict with others.

https://www.sicpers.info/2018/03/why-inheritance-never-made-...

Yes, our brain is good at this - but it still takes some capacity in processing to do this. I guess the point is: if you have a simple, high-contrast background - your brain needs less capacity to process it.

Yes, it's not really MIDI 2.0 related, but with the update they will also add multi-client support for MIDI 1.0, so I can record and still use the MIDI input as input to a virtual instrument.

See announcement here: https://devblogs.microsoft.com/windows-music-dev/windows-mid...

Looks really great! If I had a standalone keyboard I'd be considering this!

Your project got me thinking - here's one idea: Windows should get MIDI 2.0 support soon, incl. non-blocking MIDI reading if I understood correctly. That should make it possible to create a small background application that records all incoming MIDI from all (or chosen) connected MIDI devices. It would work very much like your recorder and could share the same mobile app?

This I would be interested in. Since it's a software only solution, it could be cheaper and lower entry barrier.

The MIDI keyboards I know will always output the pedal as part of the overall MIDI out. The pedal is connected to the keyboard via jack cables - or do you have a pedal that has its own MIDI output?

Thanks for writing this up! Sounds like you really dig deeply in to this.

Not entirely sure what you mean with canonical representation (I've heard this in the context of JSON-LD before, though). Can you explain what you mean here?

Where do you see the problem with Graphs and Dos? A reference is just a pointer. You just have to be careful when doing recursive code. I actually like the idea to explicitly define how a reference / association is made, because otherwise people will have to re-invent ID and association concepts and there's no shared understanding. In JSON Schema, you cannot properly express an association or graph structure and people start using overloaded and not well-defined concepts like `$ref` which is a separate standard.

The main advantages of XML (or any standard) is adoption and a wide ecosystem. Unfortunately that beats any "better" standards by a wide margin.

One thing that is also really important is the ability to define a schema and be able to validate. See XML Schema, JSON Schema. This is a really tricky problem to get right. Especially if you try to do both with the same model (describing your data model and describing how its validated) at the same time.

Once you have the schema, IDEs like VSCode offer code-intelligence and real-time validation, which is very nice.

At least Node.js has added experimental support that seems to do that: https://github.com/nodejs/node/pull/53725

But this is just an on-the-fly transpile(natively supported). It would be much better if JavaScript would go the Python route. For that they would have to extend the EcmaScript spec (to be safe) I guess.

Just using JSDoc is imho not a good alternative. The big benefit of TypeScript is that your compiler checks this all for you. I've seen to much incomplete or wrong JSDoc in my life.. also a nightmare to maintain.

If you're also interested in Software Architecture (at least the high-level), then I can also recommend https://architectelevator.com/book/ by Gregor Hohpe (who also wrote another long-time classic: Enterprise Integration Patterns).

Another one I found very helpful is Designing Data-Intensive Applications by Martin Kleppmann.

I know its a third party extension, but I created an open-source browser extension that helps me with a lot of that (I also use my bookmarks extensively for this):

https://github.com/Fannon/search-bookmarks-history-and-tabs#...

If you're afraid that it goes 404: This extension is open-source, very easy to build and use locally and it does not make any external request or relies on external dependencies.

Is it always the same word?

My word is between Vodka and Vomit :D

What worries me about those kind of job roles is the missing or very slow feedback loop.

As a programmer I can learn quickly and get better, because I have very quick feedback loops when I do something wrong (compiler, CI/CD, continous deployments).

As a manager, architect etc. the feedback loop is month, years - if you ever really get something back. That makes it really hard to find out if you're really doing a good job or if you're trading short-term gains for long-time losses.

I personally think, this is why we often are so unhappy about managers or architects in our field and developers often look down on them. But it's just really difficult (and often unrewarding, see article) to get good at these roles.