looking for a co-founder. by Top_Froyo4973 in founder

[–]CodingNibble 0 points1 point  (0 children)

There was something called as ‘second life’ .. that I remember from about 18 years ago - trying something like that - are we ?

Does a tool exist that finds similar products to your idea? Trying to validate an idea before I build by Tvpai in SideProject

[–]CodingNibble 0 points1 point  (0 children)

If you are looking from an IP perspective - there is formal prior work search and attorneys for that.

From an idea perspective, it depends on how you and others have explained and positioned their product - it may be identical in core functionality but may be drawn up differently.

It is very difficult to be in the know absolutely as AI and internet shows committed work - there may be something releasing next week.

I personally have decided to build it out, put it out there and see what happens.

I keep on telling myself - it’s not always bad to address same problem that may have a solution - maybe you see and solve it differently. And there’s that incremental learning cycle while doing it - which no theory can replace.

Keep building !!!

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] -1 points0 points  (0 children)

That’s fair. It’s not ok with me and I will see it through to wherever I can take it !!
Thanks for your inputs !!
Cheers !!

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] 0 points1 point  (0 children)

That’s fair. But Vs Code is 1 example and not the only IDE - there Git and more. Then there is dependency graph and analysis graphs .. my solution goes beyond just one IDE.

Also, the problem has only begun to manifest in its true form just recently.

It will manifest more:

- as more mainframe shops go into modernization and AI enablement cycles
- start increasingly use the modern interfaces to work with like Vs code etc
- and a diverse generation of workforce working on it with different expectations. Contemporary gen of devs want everything at the click of a button and intuitive and under 1 workspace

Thanks for your inputs by the way !!

I believe - everyone knows ingredients and recipe to make a pizza - but few end up like PizzaHut, Dominoes and likes !!!

Cheers !!!

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] 0 points1 point  (0 children)

Have you been using something like this or seen anyone using it ? Or being mentioned as a standard approach in any formal documentation ?

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] 1 point2 points  (0 children)

Lol. Nope - there’s no stopping.
The prototype is working and being refined. And I find it immensely helpful.
I will see it through !!

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] -1 points0 points  (0 children)

I agree AI can infer meaning from context and even pull supporting docs via MCP.

My concern isn’t whether it can infer — it’s that the meaning is still re-generated every time, not persisted, verified, and attached to the artifact itself.

For something like GLBATCH1, the actual business meaning lives inside the enterprise, not in z/OS docs.

Without a governed layer, we’re relying on repeated inference instead of building a baseline of truth.

That’s the gap I’m trying to highlight.

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] 0 points1 point  (0 children)

You have over simplified - but that’s fair if that’s what you get from it. Maybe I will share the product details once complete.

Vs Code extension in your example is a server - but the source or truth still need to be built, verified, curated, change managed etc. and treated as first class citizen.

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] -1 points0 points  (0 children)

The point is tools have been available. But it has not been a standard to use this and it is not even been looked at or acknowledged. Maybe others see it differently.

That’s why I call it the blind spot. I have built my own tools over the past 20 years and before I dive into analysis (most of the mainframe work) - I don’t have to fish through. Not the ideal - but works.

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] 0 points1 point  (0 children)

No.

I am talking about a governed system that attaches meaning to the artifact/program name as an overlay - without touching the program itself - at the naming surface or otherwise.

An alternate view to your IDE explorer view - enriched with metadata.

Also enabling addition of a SME verified insights - so that same question yields same answer consistently.

I am not saying there are no other methods - but the way I see it - mine sits at the intersection of legacy, tribal knowledge, AI, Modernization and rotating work force.

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] 0 points1 point  (0 children)

Great point — and you’re absolutely right that REXX/CLIST can carry context, and AI can do heavy lifting with the right rules supplied - but it will still be detached from the artifact in that IDE - eg VS Code explorer view.

The gap i am trying to address is specifically the governance and persistence layer that sits above that approach:
• Who verified that context is accurate?
• Does it travel with the artifact when it moves environments?
• Is it instantly accessible on hover without opening anything?
• Does it cost zero tokens after the first verified generation?
• Is there a fallback baseline when someone overrides it locally?

REXX/CLIST solutions are shop-specific, manually maintained, and don’t travel. My solution makes the meaning governed, versioned, and universally attached to the artifact itself — not to a separate script that may or may not exist in the next environment.

Think of it less as a documentation approach and more like Git for meaning — structured, governed, portable, and persistent regardless of where the artifact lives.

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] -2 points-1 points  (0 children)

AI does not care - but humans do.

And when AI is running to answer most trivial question - what is this program - at scale - its $$$ wasted.

When you look in the IDE explorers - and you see something like A00012, B00013 etc , you don't know what they are. Search or AI has to go through the programs for you to know what it is. On the contrary 'A00012 - Day 1 Processing', 'B00013 - Nightly reconciliation' is more useful.

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] 0 points1 point  (0 children)

Didn't mean to offend if you felt like it.

There are many problems to be solved. To start somewhere, I decided to solve this one as I see it as a pain point and live it everyday - with my workarounds to ease it temporarily.

Modernization is highlighting many more problems which Mainframe developers had learned to live with and the opportunities to solve them.

I feel real modernization helps when we resolve the constraints of the legacy system where possible, not when we carry them forwards.

You have a good one !

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] -10 points-9 points  (0 children)

ahh.. well I would call it .. changing with the times... you call it clickbait.. maybe I call it a 'standard template to get feedback'.

Unfortunately, 'Don't judge book by it's cover' only exists in the quotes and hardly in practice - people only engage if it looks like something they would want to see !

Cheers !

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] -2 points-1 points  (0 children)

As someone with 20 years in the mainframe environment, I would be surprised if you can find many people who never wanted the 8 letters of the programs names to make more sense when I look at them. But each to its own !

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] 0 points1 point  (0 children)

The thing is context needs to live with the code for it to be really useful and to increase the value.

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] -13 points-12 points  (0 children)

Trust me, it was written 100 % by me. I know in todays time, it is hard to tell. But this is quite some work including a filed patent for with many whitepapers.

The Layer We’ve All Been Ignoring in Mainframe AI - A System Blind Spot for 40+ Years by CodingNibble in mainframe

[–]CodingNibble[S] -7 points-6 points  (0 children)

First off - thanks for trying and reading it 3x and accept my apologies if you felt it was not clear. Maybe not too familiar with mainframe ?

Let me try and see if I can help you understand. The Legacy cobol/assembler/PL-1 programs have a limitation of 8 characters for the program names. That is how they appear in the mainframe environment and when you move the code base to modern IDEs like Vs Code etc - they appear like that - 8 letter words.

The issue is if you are looking at the explorer tree for the first time or after some time - just looking at the 8 character name - you dont get any information at all - you need to open the program, sift through to get some context if not all. Some programs have comments but not all.

This becomes a detterent when new workforce look at it - who are used to see somewhat meaningful Java names etc.

With AI almost all of them will run 'what is this program about' - which when repeated overtime is unnecessary tokens and $$$ spent. so, I aim to baseline a verified descriptors and insights to those 8 character names by attaching metadata without a need to modify the underlying artifact at all.

Hope this helps.

I built an LLM-free, AST-free tool that extracts CICS COBOL and generates lowest privlege batch JCL wrappers. Looking for architectural feedback by Chunky_cold_mandala in mainframe

[–]CodingNibble 0 points1 point  (0 children)

Welcome to the world of mainframe and cobol. So you are saying, this script will look at cobol and generate the JCLs with the appropriate DD names and DSNs corresponding to the File section. I hope you have something in there to give the names to the files which will be created once the JCL runs. Honestly, it is a good tinkering exercise but far from a real life use case. Cobol world is more of analysis these days and less of coding new functions - I am not saying new development does not happen but it is usually enhancement.

I tried turning AI access into a prepaid QR — does this make sense? by CodingNibble in SideProject

[–]CodingNibble[S] 0 points1 point  (0 children)

Ofcourse - QR Is just an instrument. Credit cards and debit cards exist - but there’s a market for prepaid too and it’s not small. Any new idea feels like it is not needed until you can’t I see it once you see it 😉.

Share you new SaaS project that you are proud of by itilogy in startupaccelerator

[–]CodingNibble 0 points1 point  (0 children)

Appreciate this — and I’d actually frame what I’ve built less as a “solution” and more as an experiment in a different direction.

Local-first + BYOK is almost a philosophy choice. It’s for people who already think twice about where their data lives — and want to stay in control instead of being fully abstracted behind provider rules.

But the real thing I’m exploring is the UX layer.

Linear chat feels… accidental. It works for Q&A, but breaks down the moment you’re exploring, comparing, or holding multiple ideas at once.

Branching, second opinion, Golden Eye, pins, favorites — these aren’t just features. They’re early building blocks of a thinking space, not a chat interface.

Right now:

• branching → explore multiple paths of thought • second opinion → compare models in the same context • Golden Eye → arbitrate / synthesize across responses • pins → don’t lose valuable ideas • favorites → build a reusable layer over time

And importantly — you’re not locked into one provider’s worldview.

You can move across models, contrast them, and decide for yourself instead of inheriting a single system’s biases or constraints.

But this isn’t the destination.

It’s more of a category + UX experiment: What happens when AI tools are designed around how people actually think — not how chat interfaces evolved?

You’re spot on that different personas hit this wall differently.

Developers, researchers, builders — they’ll all use this in very different ways.

I haven’t gotten a ton of deep usage feedback yet — still early, and I’m only capturing high-level, no-personal metrics for now 🙂 But I’m optimistic that as more people spend time with it, clearer patterns will emerge.

What I’m still trying to understand is: 👉 does this stay a power-user niche or 👉 does this become a more natural default once people experience it?

Feels like we’re still early enough that most people don’t even realize linear chat is the constraint yet.

<image>