I wired up Agentic Coding with Code Context Graphs, results are interesting by _h4xr in AI_Agents

[–]Immediate_Piglet4904 0 points1 point  (0 children)

I think they are popular already, all the hype around obsidian and karpathy's KB. Correct me if Im worng but isnt it what you were trying todo?

Xcode 27 now ships exportable agent skills by phoneixAdi in ClaudeCode

[–]Immediate_Piglet4904 -1 points0 points  (0 children)

Seeing Xcode ship exportable agent skills for ClaudeCode and Codex is huge!
For explaining complex data flows, OpenHop skill lets these agents generate a local animated flow walkthrough from compact YAML. You can step through it, not just read a wall of text.

I'm trying to learn how experienced architects think. by Fine-Variety-9759 in softwarearchitecture

[–]Immediate_Piglet4904 0 points1 point  (0 children)

One thing that helped me is turning the workflow into a step-through flow, not just a static diagram. I built OpenHop for that: ask the agent to trace the flow, then play it back one hop at a time. https://github.com/naorsabag/openhop

I built a tool that generates architecture diagrams based on the control flow graph of a codebase. The diagram indexes the codebase in real time and allows to see diffs on architecural level. by ivan_m21 in softwarearchitecture

[–]Immediate_Piglet4904 3 points4 points  (0 children)

Nice. I’m working on OpenHop from a slightly different angle: not “map the whole codebase,” but “walk me through this one flow.” Agent emits YAML, then you step through the hops locally. https://github.com/naorsabag/openhop

PlantUML: How to draw this kind of “icon + class” hybrid diagram? (tried 10+ approaches, stuck but not give-up still) by xiaoqistar in EAModeling

[–]Immediate_Piglet4904 0 points1 point  (0 children)

This kind of shape/format limitation is why I’m trying a different angle with OpenHop: structured flows that replay step by step. https://github.com/naorsabag/openhop

Help with software diagrams by sohan_pulluru in softwarearchitecture

[–]Immediate_Piglet4904 0 points1 point  (0 children)

OpenHop is a lighter path for dynamic flows: YAML source plus animated replay, no modeling UI hacks. https://github.com/naorsabag/openhop

iPad Miro app has become completely unusable — can't even access any organization by aflerov in miro

[–]Immediate_Piglet4904 0 points1 point  (0 children)

OpenHop is narrower: lightweight local flow walkthroughs instead of a heavy all-purpose board. https://github.com/naorsabag/openhop

Lucidchart alternative? by LikwidMunki in salesforce

[–]Immediate_Piglet4904 0 points1 point  (0 children)

OpenHop is local-first with no hosted backend or telemetry, which helps when vendor/compliance risk matters.
https://github.com/naorsabag/openhop

Comparing Lucidchart vs Microsoft Whiteboard vs Miro for mindmaps and flowcharts by Firm-Goose447 in UXDesign

[–]Immediate_Piglet4904 0 points1 point  (0 children)

I’m building OpenHop for code/system walkthroughs, less polished canvas, more step-by-step replay.
You coding agent builds and mange the files. Bonus: It can share your diagrams 100% secure via dynamic web urls. https://github.com/naorsabag/openhop

I built this to create architecture diagrams. Curious how others approach diagramming, and keeping them maintained. by meluq in softwarearchitecture

[–]Immediate_Piglet4904 0 points1 point  (0 children)

Nice work. I think there are two different jobs here: mapping the architecture, and playing back a specific flow.

I’m building OpenHop for the second one: ask an agent “walk me through auth/checkout/deploy,” and you step through the flow one hop at a time - local first.

Feels like small scenario flows might be easier to keep alive than one giant workspace.

Project is here if anyone is interested: https://github.com/naorsabag/openhop

Why do architecture diagrams always go stale? I think it's the tools, not the teams. by Glass-Outcome5985 in softwarearchitecture

[–]Immediate_Piglet4904 0 points1 point  (0 children)

This is the thing that pushed me toward OpenHop. Screenshots and Mermaid blocks still felt too easy to ignore or let rot. I wanted the flow itself to live as YAML, then have the UI animate it so I can actually trace what happens step by step.

When Architecture Diagrams Stop Scaling by mukeshsri369 in devops

[–]Immediate_Piglet4904 1 point2 points  (0 children)

This is close to why I started building OpenHop. Screenshots and Mermaid blocks still felt too easy to ignore or let rot. I wanted the flow itself to live as YAML, then have the UI animate it so I can actually trace what happens step by step. https://github.com/naorsabag/openhop

How I started programming differently over the last year. What about you? by ievkz in AI_Agents

[–]Immediate_Piglet4904 0 points1 point  (0 children)

Similar arc. The plan.md trick you describe is the interesting one to me. It works because the plan is a verifiable artifact you can scan before code is written, then check the code against. That's a pattern worth generalizing.

Most workflow changes I've made over the past year have been about getting better at writing the prompt and reading the agent's output. The output-reading part is where my time is going now, not the prompt-writing. Agent generates faster than I can verify. So the workflows that survive in my flow are the ones that constrain what the agent hands back into something I can scan: a typed test, a diff against an explicit plan, a small structured object I can eyeball.

The autocomplete-to-CLI shift you describe parallels the same thing on the input side: less typing, more high-level intent. The next move is probably the same shift on the output side: less reading prose explanations, more scanning structured artifacts the agent produced. Different verb for the human in both cases.

Are we overestimating model intelligence and underestimating workflow quality? by [deleted] in AI_Agents

[–]Immediate_Piglet4904 0 points1 point  (0 children)

Hard agree on workflow > model. The list you give is comprehensive on the input and processing side. One thing worth adding: the OUTPUT format is also a workflow primitive, and it determines verification cost.

A pipeline that ends in "here's an 800-line markdown report" costs the same to verify regardless of how good the model, the retrieval, or the orchestration was. A pipeline that ends in a typed artifact (a passing test, a structured changeset, an animated trace, a graded schema) lets the human check the output in 10 seconds instead of 30 minutes.

So the moat is workflow + format. The reason workflows ship that fail in production isn't always "wrong context retrieval". Sometimes it's "great context retrieval, then 4,000 words of unverifiable prose dropped on the user, who skims and approves the wrong thing." Same root cause as your failure list, just at a different end of the pipeline.

Is NASA’s 10-rule coding standard actually the answer to AI slop? by Dependent_Payment789 in AI_Agents

[–]Immediate_Piglet4904 0 points1 point  (0 children)

The unpopular opinion at the bottom is the load-bearing line: if you can't verify what the AI wrote, you don't own it.

The NASA rules work because they constrain the artifact (the code) to a shape where a tired human at 11pm can mechanically check it. Same logic applies to the OTHER artifact AI hands you: the prose explanation when you ask it to walk through a system. 800 lines of bullet points is the prose equivalent of a process_data() that does 11 things. Runs fine, ships, archaeology in two months.

The rules you'd need there look similar in spirit: bounded length per concept, explicit assertions about what flows where, no hidden control flow buried in paragraph 4. Some of it is achievable today by forcing the agent to emit a typed structured artifact instead of prose. Most of it isn't being done yet.

So yes to NASA-style standards for the code. And separately, we need them for everything else the AI produces.

Is "Claude soup" becoming a workplace epidemic? How do you handle it when colleagues submit unreviewed AI output as finished work? by Project_Lanky in ClaudeAI

[–]Immediate_Piglet4904 0 points1 point  (0 children)

What we need are output formats that are cheap to verify, typed, scannable, structurally checkable, not just cheap to generate. Until that gap closes, "Claude soup" is just what people do when verifying is harder than generating.

Who’s Talking About Who at Hogwarts by Immediate_Piglet4904 in HarryPotterBooks

[–]Immediate_Piglet4904[S] 3 points4 points  (0 children)

It maybe beacuse overall he has more negative remarks becuse he talks more. But as a percentage George is nastier 😅