thegagne

Used Claude to write conformance tests for https://aep.dev.

https://github.com/thegagne/aep-conformance-test

Did pretty well, only took a day or so. I first had it inventory every MUST, SHOULD, and MAY in the spec, and then let it rip. I did guide it quite a bit to get what I wanted, but at the end I’m pretty happy with it as a first draft.

Helped me learn the spec and will be helpful to hone my dotnet AEP server, and aepbase.

There already existed an aep e2e validator which does a similar thing, but this is more thorough and generates a nice report. It will tell you not just whether your API follows the spec, but also what parts of the spec it does not implement.

How is it not lights-out? You could remotely power on/off the servers (XServe only). Other Macs could not do this, as they did not have the separate LOM network interfaces, etc.

I managed a bunch of XServes for a while, they were incredibly good hardware. The Mac Server software kinda sucked (not the LOM stuff, it was as good as any of the LOM from Dell, which is to say, not amazing, but workable).

I managed a large enterprise CF account from 2018-2023. Hundreds of load balancers. The UI changed out from under us 3 times, with some big problems being fixed, but introducing new ones. I gave bold feedback directly to the leaders responsible for this, with helpful suggestions on how to make it better.

I was really glad when they fixed the old one that had a big "X" that would delete your load balancer without a warning dialog. But I was not happy that the load balancers got increasingly complex, with settings hidden at multiple layers that you had to independently configure.

Load balancing IS complex, but this is their core business, and in many other places such as DNS, Cloudflare put a lot more thought into making it simple and intuitive to use.

Getting this stuff right takes lots of strong leadership and long-term decision making with determination and wisdom to provide the best experience for customers. Unfortunately I am not confident that is how the business is operating, especially with strong talent being let go or leaving due to lack of fostering of a healthy working environment.

But who will take their place?

Hm, maybe we should go make one.

I am not a power user for Dendron, I mostly just use it for journaling, keeping track of who is who and what is what, and organizing architecture / ideas before they find a home somewhere else. Mostly a journal.

I do like that it’s in VS Code and I can leverage those tools and now, AI, to help.

The main functionality I use is the new daily journal from template feature. Do you use more surface area from it? What is the most useful features for you?

Sure, but I would say you are an outlier in paying for those things. Most people use what's immediately available, others might search for something better that's free, and very few will go pay for something.

That last category of people are also now likely to go create something themselves with AI, but don't really want to or can't start a business from it, so they may add it to the pile of free software others can use.

Not everyone HAS to profit from their work, though I do think those who make it their passion might benefit from finding a way to do that.

How many text editors have you paid for, versus how many have you used for free?

I do think there is room for a few good paid text editors in the world, but most people won't pay directly for them, though they might use them if they are bundled ala Google Docs / O365 Word.

Not all software needs to be for-profit.

Simple utility stuff I believe should fit in this category. Things like a text editor.

The profit comes from elsewhere, larger more complex systems.

Of course someone can TRY to profit off a text editor, but unless it solves complex enough problems (like a full blown IDE, but even then...).

The issue is there is intense demand for it, and ALSO easy supply. If someone attempts a profit driving rugpull, another will pop up in it's place.

I am still using Dendron because it meets my needs, but I'm always half tempted to replace it, and I'm fairly confident I could come up with something that meets my own needs in a day or two, and it would likely also be valuable to countless others. I just keep assuming that someone else will spend that day or two, and my pain points with Dendron are not that bad for me to spend the time.

Happy adopter of AEP here.

It has been super helpful and the ecosystem is growing around it.

The real benefit is having a standardized pattern for APIs, with automation and predictability built in.

Not everything can be modeled as a resource, but for any API that fits that, it’s fantastic.

It’s a bit restrictive at times, but those restrictions often shed light on bad architecture/data modeling.

They worked through a lot of feedback last year and cut a 2026 LTS release to give strong confidence to start building tooling around it.

Check out https://aepbase.io/ for an example and fun way to get started.

Hah, I think about this all the time. I think we subtly desire LLMs to be more and more deterministic and efficient. This is why one of the main uses of LLMs is building tools to make their job easier.

I made my own project, with one of the goals being discounting tokens, but found that the real goal was just ensuring quality and making things more programmatic.

https://ktext.dev

Basically ends up being agents.md in a schema driven yaml file. Thinking about extending it to also generate or replace skill.md.

I think the proliferation of markdown is cool, and lowers the barrier for entry, but it’s also very unpredictable and loose. I think over time we will drive these to be more like config files instead of free text.

I made up an attempt at a solution, https://ktext.dev.

Basically a structured context file, that can be used to generate AGENTS.md, and also can be validated and scored.

I think it could help with this problem.

If only it could fix the lag with Mac screen sharing in Teams.

This looks great, and possibly useful, but I'm curious, what was the main problem you were trying to solve, or what does this enable for you?

Love TypeSpec, agree it makes writing OpenAPI really easy.

But I’ve moved to using https://aep.dev style APIs as much as possible (sometimes written with TypeSpec), because the consistency allows you to use prebaked aepcli or very easily write your own since everything behaves like know “resources” with a consistent pattern.

Also Terraform works out of the box, with no needing to write a provider.

It mostly does, if you write it well, but it’s less efficient than XML, you have to write it by hand, and there’s no way to “validate” that it’s any good.

This is basically a structured, efficient version of claude.md.

https://ktext.dev/

Every time you launch a new Claude Code session it will need context for the codebase. Rather than letting it spend a bunch of tokens looking around and discovering it, why not provide it with a compact, high quality version?

Ktext has two parts: a CONTEXT.yaml which adheres to a JSON Schema, and the ktext CLI that helps create, validate, and export it.

Was going to launch later this week, and the site needs some tweaks, but the tool is ready.

Give it a shot!

I started building one of these myself, and got something working decently but decided it was too complicated and didm’t really provide value. I then saw GitLab Knowledge Graph. It does this, but even Claude says it’s not very efficient or helpful for the large code bases I pointed it at.

I pivoted and created something way simpler, but solving a different problem. Making the basic context really efficient and high quality.

https://ktext.dev

They changed the limits out from under us, and bugs cause usage to spike like crazy.

Which harness and how which GPU?

Out of curiosity, why did you reject Floci? It lacked some feature I needed, so I just went ahead and added them. My needs were not that complex and it has patterns to test that implementations match AWS. I agree it’s lacking things, but the bones aren’t that bad.

Not if you are part of an org that uses MDM and pushes their own CA to devices.

I think that it has two flaws:

- It is too machine like in its definition and requirements and misses the spirit of the ask.

- It very much waterfalls it, without asking for feedback midway, or revisiting the original goals after things have been built. You have such an opportunity to adjust and learn as you go, especially if you keep revisiting your goals and values and re-evaluating your original requirements which may have been flawed.

Just like with human development, it's rare that your spec is well thought out at the beginning, and impossible that it was comprehensive enough to define a working system.

I think having goals, vision, and hard requirements make sense, with some guiding principles along the way, but it's very much a journey that requires constant feedback loops and adjustments along the way.

I am aware of the current issues with open source licensing, but for my needs I don’t trust the elastic style licensing, especially when it claims to be open source but I can’t fork it to protect myself from a future rug pull situation.

I currently use Dendron in VS Code. Dendron is basically abandonware at this point because it couldn’t be monetized, but because it’s Apache licensed, I can fork it if I want, and continue to use it until something better comes along, or even modify it for my own needs.

It’s very hard to be successful financially in this space. Notion did it at the right time, but they are targeting enterprises who are willing to give their data to them, not individuals who want to run their own setup.

Maybe you can compete with Notion, but I’m not willing to put my stuff in a system that may not be around in a couple years, and I don’t have a license for.

Speaking of methodical, have you tried AWS Kiro?

It has spec driven development, which in my testing yesterday resulted in a boat load of passing tests but zero useful code.

It first gathers requirements, which are all worded in strange language that somehow don’t capture specific outcomes OR important implementation details.

Then it builds a design file where it comes up with an overly complex architecture, based on the requirements.

Then it comes up with a lengthy set of tasks to accomplish it. It does let you opt out if optional testing, but don’t worry, it still will write a ton of tests.

You click go on each set of tasks, and wait for it to request permissions for odd things like “chmod +x index.ts”.

8 hours and 200+ credits later, you have a monstrosity of Enterprise Grade Fizzbuzz.

Consumers are sick of being the victims of a power imbalance already. Social media sites do this kind of personalization on their feeds, but they do not provide the user the power to control their own algorithm.

If every website is tracking my identity and surrounding me with an echo chamber outside of my control, that is not a good thing.

If the profile and prompt is something the user controls, it could be useful, but it’s still hard to trust it. It takes away the ability to have trustworthy links to information/products, if it’s different for every user, especially if the customization methods are hidden behind opaque LLMs and system prompts.

I do think this idea can make money, but it’s likely bad for the internet consumers and likely to be part of future enshittification.

Discovered AEP this last year and started working with it. It's become a very valuable part of our API Design tool process, along with TypeSpec, OpenAPI, and Zudoku.

Check out https://aep.dev, they have a CLI tool for doing that, _if_ you write your OpenAPI to follow their spec. We are adopting it, both because of the nice standard it provides and also for the guaranteed tooling (TF, MCP, CLI).

What’s in your toolkit for server and client generation?

I organized #mst3k for a while and we collected pretty much all of the existing episodes. Good times.

Efficiency and ease of adoption would be my guess.

The APNIC Ping podcast did an excellent 2 part series on the problems of DNSSEC. It puts more responsibility on the DNS systems that are already complex and doing a lot of work.

The CA system with root trusts is just super efficient and easy, so it won.

It’s not perfect, so I’m sure someday it will be replaced, but not by the current options.

It’s been a while but I used a bunch of these tools continuously for years. I mostly always used sslyze, because it was very versatile and gave me the info I wanted, whether it was around ciphers, tickets, cert chain validations, etc. I think testssl.sh did almost or possibly everything I wanted, but not sure.

SSLyze also has a decent Python library.

The problem with it though is the license. I wanted to build it into some other tooling but the license held me back.

I ended up building my own tooling that did just what I needed and built an API around it.