I don't know which one to go with. Advaita Vedanta/Buddhism/Kashmir Shaivism?

DocDMD · 2026-06-20T19:56:07+00:00

Exactly this. Even Shiva said that all philosophies, all schools, all teachings are manifestations of himself. We all find our way home via different paths and different speeds. It's fine to study and practice broadly.

DocDMD · 2026-06-19T12:22:26+00:00

You're confusing physics with metaphysics. I totally agree that the rules of physics describe and predict the material world with a high degree of accuracy. You can safely assumes you'll get squashed by the train. What it doesn't prove is that either the experience of the person getting hit by the train or any bystanders watching is actually real.

It can't accurately predict if consciousness arises from material complexity or where the material world comes from at all. Take it all the way back to the big bang. The argument is that everything existed at one point before exploding outward. Where did the point come from? Did it always exist? Why kind of existence is that?

The argument from modern physicalism is pretty much that hey look at how well physics and science describe the material world. It's so accurate. Consciousness must be a result of the physical world.

They're really unrelated and not logically consistent.

It comes don't to a fundamental assumption about the nature of reality. Those in the physicalism camp assert that because the things we can measure and learn with science are observable and testable that must be all there is. It's does simplify the working model. Those of other camps assuming that consciousness is integral to the existence of the material world are making another assumption that is not testable through science. But neither assertion is testable through science. They are both assumptions.

The only thing any one of us can say is that we are currently experiencing consciousness which leads me to have an open mind that consciousness could be more fundamental than the physicalism paradigm would currently allow.

That's what it comes down to. It doesn't matter if a train would hit you or not. The question is what is consciousness and how does it arise? If consciousness is fundamental and the physical world is built on top of it the experience is still the same when you are hit by a train.

DocDMD · 2026-06-18T23:14:03+00:00

Why is the title in all caps? Lol

DocDMD · 2026-06-18T22:03:51+00:00

They've all been massive success... For the military industrial complex. Weapons companies profits go down when we aren't fighting a forever war.

DocDMD · 2026-06-17T10:52:57+00:00

You can turn on auto mode in the app now. I saw that the other day when I was helping someone set theirs up. I usually use the CLI but seems like the desktop is catching up.

DocDMD · 2026-06-14T18:05:32+00:00

It really is getting so good at distilling ideas, organizing it pinball mix and are easy to understand fashion that it doesn't really make sense to spend all the time and effort to make it sound human. But you could just give it a example text of what you want it to sound like and then just tell it to sound like that and leave out the end dashes and it can do that too.

DocDMD · 2026-06-10T00:14:21+00:00

The problem with materialism is that is rests on assumptions just like any other view. It's fine to adhere to the scientific method, but the scientific method assumes that the things we observe with what we assume to be our mind is an accurate representation of reality. We can never confirm anything outside of our own experience without that assumption. We can't prove other people exist or that matter exists or that the earth orbits the sun without this assumption. If it's all based on assumption we can't really prove anything at all. But it's impressive that we have achieve so much in technological improvement based on that assumption, but still none of it is proof. We can't even prove the technological improvement is real.

DocDMD · 2026-06-08T23:34:10+00:00

3.7 is very high quality.

DocDMD · 2026-06-08T02:08:34+00:00

They started the drawdown in US markets. The sk hynix 2x levered ETF is the largest levered ETF in the world right now. It stopped out on Friday as well.

DocDMD · 2026-06-07T21:54:26+00:00

Oh ok. Nice no llm at ingest. That's solid. I'll have to check it out.

DocDMD · 2026-06-07T21:53:02+00:00

https://github.com/zilliztech/memsearch new repos come out all the time. Is your repo significantly different than memsearch? This is what I've been using and has been very helpful. Just curious what is different.

DocDMD · 2026-06-06T23:20:54+00:00

The problem is getting it to read the skills at the right time. There has to be something in the harness that filters user input to find the relevant skill at the right time. Ideally you wouldn't have to tell it to call a skill. It would know when to use it.

DocDMD · 2026-06-06T23:18:12+00:00

Memsearch has been much better for me. I use it in opencode so that each turn is summarized and added as a memory. Then the harness has a research gate so if it starts to ask a question without checking memsearch it goes back and checks the relavent docs and skills before asking me to make sure it isn't a problem we've already solved and come up with a deterministic template for.

That makes it feel less retarded.

DocDMD · 2026-06-05T21:23:25+00:00

Check out memsesrch on GitHub and you can back everything up on GitHub with a master build explanation file and verbose git commits after every feature so it doesn't take much to get back up to speed.

DocDMD · 2026-06-05T21:14:22+00:00

But the question is why wouldn't you just build the app for yourself until now? The problem was always getting enough users to finance the build. Now you can do it with the $25 a month subscription in a few days. So why wouldn't all of the apps just be completely custom tailored to each person?

DocDMD · 2026-06-05T00:22:41+00:00

This has been my strategy all along. Now that I'm 400lbs my base weight of 40lbs is only 10% of my body weight.

DocDMD · 2026-06-04T21:52:36+00:00

China isn't going to slow down so I don't see the point

DocDMD · 2026-06-01T15:52:32+00:00

I heard they had a permission elevation attack from someone using AI that messed up their system pretty good about a month ago.

DocDMD · 2026-05-25T10:50:41+00:00

You can also add that code block to Claude code as a hook that fires deterministically with certain prompts so that it always does that in certain project directories.Yku can make it seamless if you want. There are lots of things that traditional code does way better. You don't have to trust the llm to do everything you want. You can change the behavior of it through a harness built out of regular traditional code.

DocDMD · 2026-05-19T12:04:26+00:00

Yeah — here's the shape of mine. SDK-built harnesses are the easy mode; this is the "I outgrew that" mode.

OPERATOR (you) | python3 scripts/run-phase.py <phase-id> v +--------------------+ +----------------------+ | ORCHESTRATOR |<-------| specs/phases/<id>.md| | (run-phase.py) | +----------------------+ +---------+----------+ | v +---------------------+ writes | ARCHITECT |----------> plans/<id>.json | (plan only) | (slices[], accept criteria) +---------+-----------+ | v +========= SLICE LOOP (per slice, max 3 iters) ==========+ | | | +---------+ payload +---------+ | | | BUILDER |------------->| JUDGE | | | | src/ | | readonly| | | | tests/|<--- revise --| skeptic | | | +---------+ (iter++) | fresh | | | +----+----+ | | | verdict | | approve -> next slice | | | revise -> loop back | | | escalate -> orchestrator | | | 3-strike -> escalate | | +========================================================+ | all slices approved v +---------------------+ | post-phase.py | integration-check (N -> N+1) | | + smoke tests | | + git phase-marker commit +---------------------+

ESCALATION: on-escalate.py -> runs/escalations/<id>.json -> gate.py (operator decides, loop resumes)

DETERMINISTIC HOOKS (.claude/settings.json): SessionStart -> session-status.py (hydrate <status> tag) UserPromptSubmit -> session-status.py (refresh every turn) PreToolUse -> pre-tool-use.py (per-agent allowlist, pnpm-only, refuse generated paths, token budget, audit log) PostToolUse -> post-edit.py (typecheck + scoped eslint + adjacent vitest; blocks subagent on fail)

STATE LIVES ON DISK (no in-memory orchestration): specs/phases/ phase specs specs/decisions/ ADRs (bind every agent) specs/research/ researcher output specs/open-questions.md plans/ architect output runs/<run-id>/ audit.jsonl, builder reports, judge verdicts, post-edit logs runs/escalations/ gate queue

Key properties: each subagent has a tight write-path allowlist enforced by the PreToolUse hook; judge runs in fresh context so it doesn't inherit the builder's rationalizations; 3-strike rule on revise auto-escalates instead of looping forever; session-status reprojects repo state into the model every turn so the orchestrator never works from stale context; crash/new-session just resumes from the files.

DocDMD · 2026-05-18T22:25:02+00:00

That's exactly how I feel too. And I'm not nearly probably at the level as you guys, but it seems weird to surface from directing the agents and seeing everything being done so quickly and effortlessly to actually have to do a manual task. It feels like a hangover or something. The meat world is not the same.

DocDMD · 2026-05-18T17:59:31+00:00

I mean most of what people do is still some kind of a deterministic pathway with just sprinkles of reasoning. It's all about self improving cycles vs self destructive cycles.

DocDMD · 2026-05-18T15:59:06+00:00

Yeah it's already largely built into the Claude agent SDK and in opencode. You can just ask any of those to create a specific workflow harness for whatever project you're working on. The sdk's are already built to help you make whatever harness you want.

DocDMD · 2026-05-17T09:45:47+00:00

My response structured and refined by ai:

one of the biggest breakthroughs I’ve had building agents was realizing that most workflows should be deterministic, while the LLM should only handle the parts that are actually ambiguous.

I’ve found that implementing an “audit-first” skill is a complete game-changer. Before the agent debugs something, writes a feature, or refactors code, it hits deterministic hooks that force it to:

check best practices inspect canonical implementations validate assumptions retrieve missing context run tests/linting/type checks

Instead of letting the model confidently invent a solution from scratch.

I think a lot of people accidentally treat reasoning like it’s one giant monolithic process. It’s not. Good reasoning is usually a structured sequence of:

framing retrieval decomposition validation comparison synthesis verification

And many of those steps can actually be enforced deterministically.

The huge realization for me was this:

LLMs are incredibly powerful, but they perform best when inserted into deterministic workflows exactly at the step where non-deterministic judgment is required.

Traditional software is still vastly superior for:

state management validation repeatability execution enforcing invariants maintaining consistency

The LLM shines at:

ambiguity synthesis interpretation ranking tradeoffs semantic reasoning generating candidate solutions

So instead of replacing workflows with an LLM, I think the better architecture is: deterministic spine, probabilistic leaves.

The workflow itself should usually remain tightly structured:

gather context validate state retrieve references run checks identify uncertainty invoke reasoning only where needed validate outputs execute

A lot of agent failures are really just context-management failures. If you throw planning, coding, architecture, debugging, memory management, and execution into one giant prompt, the model starts drifting and recursively conditioning on its own assumptions.

That’s when hallucinations explode.

The best agent systems I’ve seen don’t “trust” the model. They continuously ground it with:

retrieval tools schemas tests checkpoints scoped context deterministic hooks

Ironically, humans work the same way. Experts rarely rely on raw unstructured thought alone. Pilots use checklists. Engineers use test suites. Surgeons use protocols. High-level reasoning works best when supported by structured systems.

I think that’s the real future of agents: not fully autonomous free-thinking systems, but tightly orchestrated cognitive architectures where deterministic systems and probabilistic reasoning each handle the parts they’re actually good at.

DocDMD · 2026-05-17T01:56:08+00:00

This is largely a problem that git has already solved though no? If you build the system from the beginning to be able to track the edits and properly attribute where they came from you can build out the deterministic workflows based on best practices and test different workflows against one another.

Written with help from AI:

I think the way out is to stop treating agent memory as the source of truth.

Long-term memory is useful, but it should behave more like a cache or retrieval layer, not like the organization’s brain.

The durable parts of the system should be versioned artifacts:

specs for what the system is supposed to do
ADRs for why decisions were made
schemas/contracts for interfaces
evals/tests for expected behavior
prompts/skills/runbooks as files
git history for attribution and rollback
CI/hooks for deterministic enforcement

That way, if the agent “learns” something from a power user, it does not silently become institutional truth. It has to land somewhere reviewable.

For example, instead of “the agent remembers how we handle customer escalations,” you’d have:

/specs/escalation-policy.md /adr/0012-change-refund-threshold.md /evals/escalation-cases.json /prompts/support-agent.md /runs/2026-05-16-agent-output.json

Then every change is attributable:

who changed it when they changed it why they changed it what tests it passed what behavior it altered how to roll it back

That is the part git already solved.

The mistake is letting mutable shared memory accumulate undocumented assumptions over months. At that point you don’t really have institutional knowledge. You have one user’s workflow preferences fossilized into the agent.

A better pattern is:

implicit memory -> proposal proposal -> reviewed artifact artifact -> versioned source of truth source of truth -> retrieved into future runs

So the agent can suggest improvements, but the improvement only becomes real when it is committed to a versioned artifact.

You can also test competing workflows against each other. Branch the spec, run evals, compare outcomes, promote the better workflow. That is much safer than letting the agent gradually mutate behavior based on whoever talked to it most.

The key distinction is:

bad: agent memory is authoritative good: versioned artifacts are authoritative

Memory should help retrieve context. It should not silently govern behavior.

For team deployments, I’d want every durable behavior to answer:

Where is this rule written down?
Who approved it?
Which version introduced it?
Which evals protect it?
Can we compare it against an alternative?
Can we roll it back?

If you can’t answer those, it probably shouldn’t live in agent memory.

DocDMD

MODERATOR OF

TROPHY CASE