Terretta

Importantly, anyone can get SOC2 (Type 1) by claiming some controls they figure they'll look at themselves.

SOC2 (Type 2) in theory requires an audit that you're actually doing what you said you'd do in (Type 1).

Both may also allow general lag time.

Note that firms decide on their own which controls to include, meaning, they get to decide to include or exclude various controls, the audit is on only the ones they picked. Pick basic controls, it's cheaper to pass easily, and now you have a logo.

This means SOC2s of either type cannot be compared to one another (and SOC2 Type 1 are roughly logo-ware).

SOC3 is, roughly, SOC2 redacted.

Recap:

SOC2 Type 1 is a firm picking some controls to say they'll do them, SOC2 Type 2 is roughly a firm having someone look at whether they're doing that (warning, screenshots might suffice, audit verification is probably not what you think), and SOC3 is public or non-confidential water down of that, typically without findings.

The only thing that matters is what controls, specifically, they're actually audited on. So ideally you want to know what the controls they picked are, and that a SOC2 Type 2 was audited on those.

Btw, keep in mind that "end to end encryption" means "https" and most controls have similarly basic ways of achieving them. It's difficult to fail SOC2 Type 2 core controls if you know "don't be useless" is how you pass them.

Also, it's not $50K even through the big five DIY SOC2 Type 2 shops. You can use the same ones trillion dollar firms use, by signing up online, and you'll be surprised how inexpensive relative to the cost of failing to let a business check that box in their procurement process.

The design previews are all the missing thumbnail icon…

More importantly, are the customers of YOUR customers exclusively devs?

If the customers of your customers could include small businesses, then the stack you offer them should prob be capable of the simpler OIDC (Continue with...) instead of / or in addition to OAuth (Sign in with...) and probably Microsoft along with Google. And if the customers of your customers include middle class and up American consumers, also Continue with Apple.

for local LLM, obvious choice:

idle = doesn't have to be H200 speeds

uses macs = local LLM can use all the ram, be smarter

as for hosted models, potato is tasty

Fitz, Dave, whoever is "here" ...

What prompt are you using to generate this exact form of thing?

Problem history story...

Everyone's doing it wrong...

Proof of claims ...

Abstract ...

"Honest" bustedness ...

Keyword stuffing ...

Call for feedback ...

"What I'd really love from Dave:" is what's causing this particular structure. What model/harness/agent are you using, whether automated or pasting it yourself?

comprehension trumps context

Consider context as hyper-dimensional coordinate vectors gesturing at the starting concept cluster of a synthesis chain or thread to unspool.

If the model's comprehensive training activated by your context locates the right thread to pull, this could be considered comprehension? That it "got" it?

sure it's not pronounced Kenobi?

they stylize it k•no•b or k•no•b1 take your pick

https://github.com/Pylons/pylons

keyword collision: `framework`

Sit with that for a second.*

* is in the article

you have a premise at the heart of that:

understanding anything in the way humans do

i'm not sure it's clearly established LLMs can't be a model of some part of “the way humans do”?

to be more specific, i'd argue LLMs “understand” awfully similarly to a brilliant (polymath) with early dementia or Alzheimer's

no executive function, no short term memory, and absent both of those, conversing with that person about the past or with an LLM about topics that had been "in their training sets before a cutoff date" is surprisingly similar, right down to: introing a topic precisely the same way, you'll experience the same conversation; convo loops if bits are too quantized (looping and lossiness / recall / context-length are correlated); and ofc opening a new session is like the first one never happened

simple changes to SwiftUI interfaces I’ve one-shot is always a frustrating experience for me

1) Have you exported Apple docs from Xcode and provided those to your LLM and told your CLAUDE.md to read them as applies?

2) Have you added https://github.com/dpearson2699/swift-ios-skills to your agent?

I'd also recommend Xcode 27 beta unless you teach your agent the Xcode MCP. Xcode 27 beta works on MacOS 26.x.

It talks out loud to hear itself think. So, it doesn't fully know what it thought until it's said it. No joke.

To overcome it seeing your phrase and using it more, try to convey the concept you want it to say "found an indication suggesting there may be a problem underneath" in response to. That works better than telling it to do not use terms you remind it of.

Btw, you're in good company…

With both OpenAI and Anthropic, from time to time you see it stream a response to you that then changes and rewrites under your very eyes.

Those are things they, themselves, where they sit in the token supply chain, can't get it to not say until it's said it.

The presentation of the idea steers it into it.

Early on, it mattered to say "Avoid" (an active word) "action", rather than "Do" (affirmative) "not" (negation) "action" (affirmative again).

These days I take a pass on the rules to remove the bad thing from the rule and rephrase in terms of the desired behavior instead.

So it doesn't have to try to do not think about the pink elephant.

Fairly certain it's when its confidence level is too low on the right word, it hits a stock phrase instead.

When you see the metaphor or euphemism or simile is off, the selection is not quite apt, it seems the stock phrase or term is rather more probable however askew than the precise phase, and it was already low confidence about what it's trying to say, so – as it's never said – Bob's your uncle.

"Honestly/honest" is, um, absolutely (ahem) one of those and if one listens carefully, one will notice humans use "Honestly? Blah blah…" that way as well.

It taps into load-bearing speech to prop up (see, that works) unsupported claims.

All the words I just used are correct in that sentence, doing exactly (ahem) the work they're supposed to. It doesn't have that level of nuance, isn't sure, so tries to sound like what's probably right.

They're a verbal shrug.

the concept being referred to is clearly extremely important and valuable to refer to

On the contrary, stock words pop up more easily when it has less confidence.

Stock phrases are a correctness smell.

I hope it's actually talking to itself at higher bandwidth, and hope this is because of training that succeeds better given quality inter-agent communication.

For those who care to read everything rather than walk away, Fable can be extraordinarily dense. I suspect they'll pull the promo before I learn to read it.

Still, I feel I must read rather than correct it, as results are that much better if I let it do this "with" itself: orchestrator to agents back to orchestrator.

Yes, it's like corrective scar tissue in the final output.

WTH is a "fold"?

I think Claude means something like map-reduced or at least a functionally derived series of some kind?

Anything with series data sounds like a laundromat.

Cookies also don't work on mobile

Instead of speculating, I'll ask: what does this mean?

Same problem, same solution: For technical docs, tell it when facts change, rewrite as if the wrong fact never happened, with no references or even allusions to the obsolete fact or the change. It's been effective.

From time to time I have to go further and tell it to imagine an alternate reality where the fact never happened, and write this doc as if the new thing had been true all along. This second iteration always gets it.

(A separate instruction keeps the fact-change in a dev log that serves as basis for release notes.)

Contentless article, roughly children's school primer level.

TL;DR: Drones see shapes as patterns. Paint other patterns on shapes, the drones get confused. If you want to keep confusing drones as their programming learns to recognize better, your patterns have to get better.

That's it, that's the whole thing.

// No commentary on heat, lidar, 3D, EM signature, or other "vision" using different principles.

85%* of small to midsize biz in United States are on Microsoft's office platform, not Google Workspace and Gmail.

starting with indies and SV startups and education is less risky, but the real market outside startup culture is often overlooked by those who came up inside that culture

generic IMAP is not worth the time, first class integration with M365 is worth the time

OIDC flavor "Continue with Microsoft" should be right there beside Continue with Google / Github / Whatever, on every SaaS that wants business clients small enough to make "sign up online" decisions. By contrast, for consumer, Continue with Apple would be the equivalently overlooked OIDC option if you are targeting "wallet share" (a revenue model) instead of headcount (an ad model, for instance).

* Didn't look this up. Used to be. Doesn't matter if 50% or 90%, it's substantial, and point stands: don't overlook it.

leads to poor compilation times for any language that uses llvm as a backend

it doesn't take long for user delay to sum to more than developer delay

At the level of this question, with most responses addressing Odin versus Rust or Go as in the question, I'd have been curious for community thoughts adding in Nim and Swift (now that Swift is on Linux and in any IDE that can use SourceKit-LSP).

https://www.swift.org/install/linux/

See:

"A series of small programs/tasks to compare C++, Go, Zig, Odin, D, Janet, Swift, Nim and C# to see which I like the most"

https://github.com/phillvancejr/Cpp-Go-Zig-Odin

dnspatter

(dns spatter + dns patter)

I wanted to like this and appreciated the genAI tokens were teased into a less AI-ish vernacular, but surfaces and honest caveats drifted back too far to overcome the "I'm human" signaling attempted through lowercase sentences and em dashes replaced with colons.

I agree with the problem described within, and in the dead comment here.

Refreshingly written. And like wading into the ocean on a surprisingly hot spring day, bracing.

At most any given scope, "most" systems you interact with aren't under your own control. For this, consider: because that's true, the fault is yours for not grappling with that reality.

This has been written about before:

https://ruggedsoftware.org

But even that was missing a bullet:

- recognize that my code will interact with systems I cannot anticipate, that change in ways I cannot control, and become coupled more than ever intended

Extrapolate the flight time from NYC to London in 1976 ... have you seen the J-curve?

Or extrapolate the curve for self driving cars once they were only "two years away".

Catch is, tech progress is not one curve. It's overlapping S curves, stair steps of progress and stagnation, with the next iteration starting off worse than the current one, until crossing it as the current one tops out.

A spider graph or radar chart of mutually exclusive 1d characteristics conveys information through the geometry of 2d areas.

Here, the 3d is not conveying anything as the volumes within are not MECE qualia spaces -- like sorts or like kinds of things should share common volumes.

First, OP's tool is cool, and worth trying. Yours as well, though when I see a vibed tool with no commits I wonder if the author is still using it themselves or achieved perfection. :-)

Meanwhile, the other todo list take, one I've undertaken as well, is to cross sync all the Claude Codes across all its instances on all your machines.

There are multiple projects that claim to do this. None do it fully. (They particularly have blind spots to tools that embed a Claude Code, such as the Xcode 26.5 and Xcode 27 beta.)

So: roll one's own, and in doing that, realize that it has first class tools to make back referencing transcripts normal.

Given those tools, you don't really need an extra layer.

It's like that old saying: “Don't attribute to malice – or incompetence – that which can be explained by path dependency.”

https://en.wikipedia.org/wiki/Path_dependence

OK, not the saying. Perhaps should be.

Assuming a sufficient base level of competence, more of how things go for company A vs. company B can be explained by random walks through events (their dependent paths) than by management.

A competent and persistent leader can increase the odds, but under close study, fortuitousness and serendipity – or luck of the draw and timing – have more explanatory power.

Meanwhile, just try to make your own luck. Make sure you happen to things, instead of things happening to you.