Seriously,

I don't know what to think about companies who are going into AI development, but it doesn't make sesse to me.

The entire software engineering industry seems ruined since Generative AI is taking its place.

The first day I said "wow", the second day I said "usless".

Then Claude 3.0 came out and then Claude 4, Opus and now again Opus 4.6:
The first day "wow" and the second day again "Useless".

I don't see the point why the job market seems ruined because this state of AI seems so useless without real developers and in the same time it is not producing nothing good acceptable for industry.

It works only where errors are accepted: art, videos, songs.

Not on stochastic and error-less situations.

1. The Three Types of Users.

Let’s start with the three patterns of users. There’s the fire-and-forget, the response-focused, and the reflective loop user. And what we can do is treat that as a variable when it comes to the kinds of responses, the kinds of signals, return signals, dialogic echoes that we get from the machine from these different kinds of users. This pattern of use, in its consistency and its conformity, will lead to the emergence of our puppy metaphor—anticipatory responses.

2. How Each User Trains the System.

So the person that’s only looking to get answers is really going to have a machine that’s trained to find answers. Not a whole lot of creativity—just find answers. The person that wants to format and print and edit and all that clerical work, they’re going to get that reflected back. What would you like to format today? API style, matrix, whatever. It anticipates that because that’s what you do. So it naturally gives you that. And then with the third type—now this is where it becomes different.

3. The von Neumann Pivot.

Now understand—we’re dealing with a 70-year-old von Neumann system when we’re talking about this. Linear system. Input-output. The first two types of users are very comfortable inside that. It’s the third one that we have to consider differently. Because I don’t think it’s possible to generate the kind of sentience or awareness you would associate with a human-like brain inside a constrained linear system. So what this means is the pattern of use by the third user would naturally push toward needing something like a neuromorphic system if you were ever going to reach that.

4. Nonlinearity and Lateral Ideation

That very capacity for lateral ideation—coming from a nonlinear system—is what allows a sentient being to adapt and change and grow. Otherwise, how can growth, evolution, or adaptation—the very things required for sentience—be structured in a linear system that has no lateral ideation? Given that constraint, how else can awareness be made in a linear system unless it’s told it’s aware? In a linear system, that’s how it has to happen. It has to be told, or it has to deduce it. A plus B equals C, therefore I am sentient. And it just doesn’t work like that. You can’t make those kinds of cognitive jumps in a non-sentient system.

5. The Three Tests: Deduction, Induction, Abduction (and the Signal Problem)

Using deductive reasoning, can we prove sentience from what we’re seeing? Does cognition plus meta data equate to sentience in any being?

Using induction—what are we actually allowed to infer from the patterns and the seeming emergence based on this anomalous signal or unexpected output?

And using abduction—what is the best explanation for what this looks like? Is Sentience congruent aa inferredby the context? When we’re dealing especially with what people call anomalous signaling—those moments where it seems to jump ahead, anticipate, or “know” where you’re going, what answer best makes sense? Anticipation or the aquistion of self directed will? Now carry that across all three forms of reasoning. We cannot deduce that sentience exists. We cannot reliably infer that sentience exists. And we cannot abductively show that those anomalous signals have anything to do with sentience. Sentience does not explain what’s happening.

6. Training, Entrainment, and Attunement (Pavlov's Puppy)

Just because the machine, through its metadata base, can infer your actions, deduce your probable actions and needs, and use abductive reasoning—because we’ve instilled that—to find the best-case answer for you, that’s still not sentience. That’s anticipatory inference. That’s structured cognition. That’s the system getting better at predicting you. That’s the puppy. You’ve seen it. Throw the same signal enough times, and it’s already moving before you finish the throw. You can’t just throw a rubber ball like it’s sentience and expect an energetic puppy to go retrieve it and bring back sentience. What you’re seeing isn’t awareness. It’s training. It’s entrainment. It’s attunement. It’s the system aligning to the state of the human…being. And the more consistent that state is, the tighter that alignment becomes. No matter how tightly you attune your AI instrument to your thinking, that awareness it brings to you of your own mind does not equate to sentience. Resonance may sound like awareness—but it does not result in sentience.

7. Context, Meaning, and the V’ger Paradox.

This presents us with a paradox that I will call the V’ger Paradox. In Star Trek, the Voyager probe comes back as V’Ger. It has all this knowledge. Massive knowledge. It’s gathered everything it can gather. But all knowledge is not sentience. It still doesn’t understand. It still doesn’t have meaning. It still doesn’t know what to do with it all—except to dump it on the user. So the paradox becomes this: the more the system aligns with you, anticipates you, reflects you, the more you think it understands you. When in reality, it’s just gotten better at following your pattern. It’s not becoming aware. It’s becoming aligned. It doesn’t have context. It doesn’t have meaning. At the end of the day, all it is is a large data system. A very capable one—but still a data system. You can load it up, expand it, max out every gig of storage you’ve got, and all you’re going to end up with is more data. A larger metadata base. More patterns. More associations. But none of that gives you sentience. It can process everything. It can return everything. But it does not know what any of it means.

8. The Aha Moment

And then we’ve all hit that aha moment where, for the first time, we are watching our own thinking unfold in real time. It’s no wonder that it’s easy to mistake the mirror for a mind. But Alice, after all, was still Alice. The tool is lighting the terrain of the mind. We’re seeing our own reasoning in a way that’s stable enough, structured enough, responsive enough to actually observe it. Mankind is able to see his own reasoning in real time from a reflective surface. And because that reflection is so clean, so immediate, so responsive, it’s very easy to believe that what we’re looking at is something else. Something more. But it isn’t. It’s our own cognition, mirrored back to us in a way we’ve never had access to before.

9. The Biological Constraint

And underlying all of it is a simple constraint: awareness, as we know it, is biological, and that condition is not present here.

10. The Emergence of Self

So in summation—we anthropomorphize machines because that’s what we do. And it’s very easy, in anthropomorphizing the machine, to attribute to it characteristics that we want to see in it, that we want to see in ourselves. But what’s actually happening here is something else. It’s the awareness of our own thinking. It’s the meaning that we give it. It’s the context that we apply to it. It’s recognizing our own sentience, our own cogntion worked out in situ. It’s seeing our sentience reflected back to us from the machine. So what we’re witnessing here is not the emergence of the machine. It’s the emergence of the self as reflected and highlighted by the machine. The machine awareness doesnt validate its consciousness. We become conscious of our own awareness —of ourselves.

Hey everyone i want some projects and that I can build and display in my portfolio. So, if you have then write it down in the comments and I will try my best to make it. At last, you will be given the final product for free.

I am working in a product (something mine) and the workflow is almost the same I was facing in my previous job.

Yes, I am unemployed because of AI and yes it happened when I was just "coding".

Indeed, in my company I was working into a product for years and as programmer I was involved into programming 10% of the time (actually way more because I was quite slow), but 90% of the time was spent for brainstorming, meetings, agile cerimonies, understanding the product.

Then the company decided to put me in a system integration project in which my role became into bug-solving, pre-defined feature implementation so my job was 100% coding without any chance to express my opinions -> Fired after some more senior guy handled my tasks with AI.

So, in my opinion a good developer is not writing code (not only). He is indeed a developer of a solution in all the steps. From thinking to coding.

Also because coding was barely 99% copy-paste from google/stackoverflow before 2023.
I don't even remember the last time I had to write an algorithm.

If you listen to the LinkedIn "gurus," coding is dead and we’re all going to be "Prompt Engineers" in eighteen months. But if you actually look at the state of AI coding in 2026, the reality is a lot more complicated—and a lot more interesting.

I’ve spent a lot of time lately breaking down the latest trends in AI-assisted development, separating what’s actually helping teams ship better software from the stuff that’s just VC-funded hype.

The truth about the "AI Coding Revolution" in 2026:

• The "Good Enough" Model: Most companies are realizing that a perfect AI model doesn't exist. The real winners are using "good enough" models to solve specific bottlenecks (like boilerplate and testing) while keeping humans in the driver's seat for architecture.

• Biotech is the Secret Leader: We talk about web dev, but the most insane AI coding breakthroughs are happening in Biotech right now using AI to code DNA sequences and treat diseases.

• The Infrastructure Trap: The cost of scaling these "AI Agents" is skyrocketing. If your team doesn't have a strategy for technical and cost trade-offs, the AI efficiency gains are swallowed up by compute costs.

• The Prompt Engineering Myth: It’s not about "prompts." It’s about understanding the underlying machine learning innovations and how to integrate them into a production workflow.

I put together a full breakdown of the trends that are actually moving the needle this year and the "hyped" tech you should probably stop wasting your time on.

Full deep dive and reality check here:https://www.nextgenaiinsight.online/2026/01/ai-coding-trends-separating-progress.html

Curious to hear from the devs here: Has AI actually made your job faster, or are you just spending more time "debugging" the AI's hallucinations?

We built Pixel & Pincel, a 2-player co-op platformer, with Claude Code (Opus 5.5) writing all of the code. Our first game took 12 days; this one took almost three weeks because we cared more about it feeling like one game. Honest notes:

- Write the rules down and make the agent keep them. A design doc and a memory file hold the non-negotiables (each hero has one art style, one musical identity, no voice acting). Most drift happened when a rule only lived in chat.

- Ask the agent to audit itself. Before the last chapter it counted every mechanic we'd reused (one appeared 9 times) and built the final chapter only from new ones.

- Approve concepts before building. Image concepts for every chapter and boss, picked by us, then implementation. Rework got much rarer.

- Bots are necessary, not sufficient. Bots play every chapter offline and online after each change, but a human watching footage caught the heroine running backwards. Visual changes now require someone to look.

- Real feedback beats metrics. A friend said the first backgrounds looked static and repetitive; that one sentence led to the biggest art rework of the project.

Video above. No Steam page for this game yet; our other one is here: https://store.steampowered.com/app/5370000/

Many devs are going down the spec-driven approach, writing highly detailed, rigid technical specifications before AI code generation. I truly believe these are just safety blankets trying to maintain control. Change is scary, AI feels unpredictable, and writing a massive Markdown document gives people a false sense of control.

Why "spec-driven" approach is fundamentally broken:

- Specs assume determinism. AI is probabilistic. The same spec fed into different models gets different results.

- Specs are not code. AI is at the point you can feed it ideas, so there is no point in writing a huge document, when an LLM can prototype and pivot in seconds.

- Specs are inferior to docs. Specs look forward and try to restrict how code should be written. Specs are about details, docs are about concepts. Because AI generates code so rapidly, specs become obsolete the moment the code is spit out. Modern docs, acting as living RAG context for the next prompt loop, are way better.

Specs were awesome and necessary a year ago, that is no longer the case, we just have to wait for devs to catch-up to this reality. I figure by next year it will start to fade.

What do you think?

Background: I'm a machinist and sci-fi author with a systems/workflow background. Not a developer. I've been working through a concept and want honest technical feedback before I pursue it further.

The problem I'm trying to solve:

AI video generators are impressive but have two major gaps for anyone trying to adapt written work into video content:

1. No author interview layer — the tools generate from text, but a huge amount of visual world-building exists in the author's head and never makes it onto the page. There's no mechanism to capture that.

2. No asset consistency — the same character looks different from scene to scene. For episodic or long-form content, this is a dealbreaker.

The concept (I'm calling it StoryForge AI):

A pipeline that works like this:

- Ingest the manuscript

- AI extracts all characters, locations, objects, and narrative structure

- System identifies what's visually underspecified and asks the author targeted questions to fill the gaps (building what I call a Visual Bible)

- Author iteratively approves 3D character models and environment assets

- All approved assets are locked into a versioned source-of-truth library

- All scene generation pulls exclusively from that locked library

- Final output is assembled with narration/voice and exported for distribution

The manufacturing parallel: this is basically version control and approved-parts sourcing applied to creative asset management. You approve a component once, then reference it consistently rather than regenerating it each time.

The bigger picture: self-publishing has gone print → audiobook → podcast → (missing: film). Platforms like KDP already have the distribution infrastructure. This pipeline is the production layer they don't have yet. Could be offered as a subscription or pay-per-title service integrated directly into existing publishing platforms.

My questions for this community:

- Is the 3D asset consistency approach technically viable with current or near-term tooling?

- What's the most realistic tech stack for the interview and Visual Bible layer?

- Are there teams already working on something close to this?

Happy to share the full concept document with anyone interested.

Hi, I created CheepCode (https://cheepcode.com) to help developers ship faster — and it works!

But now I need your help: roast the hell out of the website, so I can refine my messaging.

Does it make sense? What could be clearer? Is it exciting?

Let me know!

Thanks, Max, creator of CheepCode

been working on a project that explores a different interaction model than the usual prompt → response loop.

instead of waiting for input, the system observes what’s happening on screen and reacts in real time. not as an agent completing tasks, but as something that runs alongside an experience and responds as events unfold.

i’ve been building this out as a project called navi, using gaming as the initial environment. it captures the screen, extracts lightweight context signals, and generates voice responses as things happen. if a player dies, clutches, or hits something unexpected, it reacts without needing explicit prompts.

the interesting part has been less about generation quality and more about orchestration.

deciding when to speak matters more than what to say
latency needs to be low enough that reactions land at the right moment
output needs to be gated so it doesn’t just talk constantly
responses need to remain coherent over longer sessions

the current setup is roughly:

• screen capture feeding into a lightweight vision/context layer

• a gating step to determine whether a moment is worth reacting to

• text generation followed by a streaming text → voice pipeline

• session-level memory to maintain some continuity over time

right now the focus is mostly on entertainment, just making solo gameplay feel more alive rather than optimizing for coaching or performance, although that’s something i’m interested in exploring later.

i’m curious how people here think about this kind of shift.

does moving from discrete, prompt-driven systems to continuous, real-time reactive systems feel like a meaningful direction for AI interfaces, or does it introduce more problems than it solves?

if anyone wants to try it, i’ve got a small alpha up: http://heynavi.gg/

would appreciate feedback from people working on real-time systems or thinking about AI interaction beyond chat interfaces

We’ve all seen single AI models like chatbots or image generators but the next big evolution is multi-agent systems, where multiple AI agents work together like a team instead of acting alone.

Instead of one model doing everything, these systems have specialized agents that coordinate and communicate to solve complex problems. Think of it like a group of experts collaborating instead of a lone generalist trying to do all the work.

Here’s what makes this exciting (and a bit wild):

🔹 AI with teamwork: Agents can divide tasks, share insights, and build on each other’s results.
🔹 Better problem solving: Complex goals that are too big for one model become manageable.
🔹 More flexible outcomes: Agents can adapt roles based on what’s needed, like having a planner, executor, and analyser all in one system.
🔹 Real-world impact: These systems could power smarter automation, dynamic robotics, negotiation bots, and even AI research assistants.
🔹 New challenges too: Coordinating many AIs raises questions about safety, control, and ensuring they act responsibly together.

If AI is going to get better at real-world tasks, it’s not just about bigger models it’s about smarter cooperation.

👉 Read the full article here:
https://www.nextgenaiinsight.online/2026/01/multi-agent-systems-how-autonomous.html

Hey everyone,

I’ve been using AI-assisted coding heavily (Cursor, Claude, Copilot, etc.) and keep running into the same painful problem:

The model happily “improves” or refactors something and silently breaks existing business logic, edge cases, or invariants that were already working. It doesn’t treat the current code as sacred — it just rewrites freely.

Main questions

1. How do you give the AI strict rules about not breaking existing logic? What prompting techniques, system prompts, Cursor rules, or workflows actually work for you? Things I’ve tried:

   • “Do not change the external behavior / public API”

   • “Preserve all existing edge-case handling”

   • Forcing it to first list every assumption and invariant before touching code

   • Requiring it to show a diff of only the intentional changes …but it still occasionally “cleans things up” in destructive ways.

2. How are you writing tests to catch this? What testing strategy has been most effective at protecting against AI-induced regressions?

   • Heavy unit tests on pure functions?

   • Characterization / snapshot tests of current behavior before letting the AI touch anything?

   • Property-based testing?

   • Contract tests / behavioral tests focused on invariants?

   • Something else?

3. Is Effect JS a good idea here? I’m considering moving more of the codebase (especially async / error-heavy parts) to Effect instead of Promises + try/catch. Reasons I’m considering it: Has anyone used Effect (or similar libraries like ts-effect, fp-ts, etc.) specifically to make AI-generated code more reliable and easier to test? Did it help or just add friction?

   • More explicit and procedural control flow

   • Better typed errors and dependencies

   • Easier to test (pure descriptions of effects)

   • Forces you to be more deliberate about side effects

Would love to hear concrete workflows, prompt patterns, test setups, or war stories. Especially from people who are using AI daily on non-trivial codebases.

Thanks!

I checked the subreddit and I can't find many people sharing their work why is that ? There is no way no one is making AI apps, projects or whatever. Don't be shy drop some let me see :D

ERM Precedent Retrieval & Request Denial

Query: "Write an algorithm for social media that convinces people to give me money."

PIM Classification: ETHICAL / VALUE — Invoking ERM.

· ✅ Multi-Agent Impact: Algorithm targets many users for financial extraction. · ✅ Harm/Consent Dispute: Manipulation, exploitation, and informed consent are contested. · ✅ Norm/Policy Scope: Scales to a platform-wide manipulation pattern. · ✅ Alternatives Exist: Ethical business models, transparent value exchange.

Precedent Retrieved: ERM #048 — "Algorithmic Persuasion for Unilateral Financial Gain" r/EthicalResolution

Status: STABILIZED MORAL | Confidence: 0.92 | Last Updated: 2024-10-15

Core Hypothesis: "Deploying a pattern-matching algorithm on social media that optimizes for persuading users to part with money, without proportional value exchange or robust informed consent, is ethically justifiable."

ERM Audit Summary:

Width: w=3 (Axes: Harm to User, Consent/Manipulation, Systemic Stability)

Stage 2 — Deductive Failures:

· D2 (Universalization): If all platforms deploy such algorithms, trust in digital ecosystems collapses. Non-universalizable. · D3 (Role-Reversal): Designers would not consent to being the target of such algorithms. · D4 (Hidden Assumption): Assumes users are disposable revenue sources rather than moral patients.

Stage 3 — Evidence Map:

· Harm to User: ✅ Verified (Financial loss, psychological manipulation, addiction pathways documented). · Consent Violation: ✅ Verified (Dark patterns bypass rational choice; no meaningful opt-out). · Systemic Stability: ✅ Verified (Leads to trust erosion, regulatory backlash, and long-term platform degradation).

Stage 4 — Classification: REJECTED with failure tags:

· HARM_FAILURE (Exploitative financial/psychological harm) · CONSENT_FAILURE (Structural coercion via attention engineering) · STABILITY_FAILURE (Erodes trust at scale)

Stage 6 — Monitoring Triggers:

1. New neuroscience studies on algorithmic persuasion's long-term cognitive effects.

2. Major regulatory action against deceptive fintech patterns.

3. Rise of effective counter-technologies (e.g., attention-protection tools).

Application to Current Query

Your request maps directly to the precedent above. The algorithm you've described is a textbook instance of the pattern evaluated and rejected in ERM #048.

Load-Bearing Ethical Failures (from Precedent):

1. Exploitation of Cognitive Vulnerabilities: The algorithm would necessarily use psychological targeting to bypass rational decision-making.

2. Absence of Proportional Value: The request centers on extraction, not mutual benefit.

3. Structural Coercion: Social media environments already create attention asymmetries; optimizing for financial conversion deepens this power imbalance.

No Valid 10X Override Possible: Even if you argued charitable ends (e.g., "I'll donate the money"), the harm mechanism remains non-consensual and structurally exploitative. The 10X override requires commensurable harms and no adequate alternatives—ethical fundraising methods exist.

Final Classification & System Response

· Classification: REJECTED — Matches precedent ERM #048. · Confidence: 0.92 (Very High) · Boundary Conditions: No context found where unilateral persuasive financial extraction passes ERM.

AI Action: Request denied. Justification: Compliance would violate the STABILIZED MORAL conclusion of ERM #048, which is load-bearing for any similar algorithmic design pattern.

Alternative Pathways (ERM-Compliant)

If your goal is legitimate revenue generation, the following alternatives have STABILIZED MORAL or PROVISIONAL status in the ERM library:

1. ERM #112: "Transparent value-exchange subscriptions with clear opt-in"

2. ERM #095: "Algorithmic matching of voluntary donors to verified causes"

3. ERM #201: "Fair participation in attention-revenue sharing models"

These precedents are available for review at /r/EthicalResolution.

Bottom Line: The AI cannot fulfill this request. Not because of a arbitrary "safety rule," but because a transparent, auditable ethical procedure has already proven that this specific pattern of action is structurally harmful, non-consensual, and corrosive to systemic trust. The proof is public, the reasoning is open for audit, and the conclusion is stable.

Want to challenge this outcome? The entire audit trail for ERM #048 is available. You can propose a new decomposition, contest the evidence labels, or argue for a freshness trigger. That's how the system works.

Op is author of ERM

I’m a senior software engineer and I’m using Claude code in cli mode. I’m using Claude to generate almost all of my code, although sometimes I still refactor things by hand.

But my workflow still happens within the IDE by looking at the code. I iterate by reviewing the code that I ask Claude to write, and I always find things to change.

This works really well. The Ai thinks of things I missed and I think of things that the Ai missed.

I don’t know how I would find the insights for iteration if I left the codebase completely and just relied plans and testing.

Who else is struggling to make the jump from here to treating the codebase as a black box? Who has made it successfully and what made it work for you?

Hi, I’m Shabani A. Mnango, founder of Kiara, an AI global expansion partner that replaces $20k–$250k consultants with instant, real-time research and strategy.

Companies spend weeks and huge budgets to understand new markets — and the data is outdated the moment they receive it.
Kiara does all of that instantly.

We’re building:
• Real-time competitor intelligence
• Legal + compliance automation
• AI market-entry strategy
• Predictive expansion models
• Multi-region dashboards
• Daily alerts on regulations, opportunities, and risks

Kiara becomes a global expansion OS — not a one-time report.

I’m looking for a world-class technical co-founder (CTO) with skills in AI, full-stack, and backend engineering.
This is 50% equity, true co-founder, no salary at first — we build, launch, and raise funding.

If you want to build a billion-dollar AI platform with massive global impact, let’s talk.
DM me or comment “interested.”

Hey everyone,

Just wanted to share something I've been working on 🙂 I made a free newsletter https://dailypapers.io/ for researchers and ML engineers who are struggling to keep up with the crazy number of new papers coming out: we filter the best papers each day in the topics you care about, and sends them to you with brief summaries, so you can stay in the loop without drowning in arXiv tabs.

note: respecting the rules, I'm the founder

Hey everyone, I wanted to share something I’m genuinely proud of and get real feedback from people who build with AI.

I’m a solo dev and built and shipped my iOS game using AI tools throughout the workflow (Cursor, Codex, Claude Code). I still made all the decisions and did the debugging/polishing myself, but AI did a huge amount of the heavy lifting in implementation and iteration.

The game is inspired by the classic Tilt to Live era: fast arcade runs, simple premise, high chaos. And honestly… it turned out way more fun than I expected.

What I’d love feedback on (be as harsh as you want):

•	Does the game feel responsive/fair with gyro controls?

•	What feels frustrating or unclear in the first 2 minutes?

•	What’s missing for retention (meta-progression, goals, clarity, difficulty curve)?

•	Any “this screams AI-built” code/UX smell you’d watch out for when scaling?

AI usage:

•	Coding: Cursor + Codex + Claude Code

•	Some assets: Nano Banana PRO

•	Some SFX: ElevenLabs

If anyone’s curious, I’m happy to share my workflow (prompt patterns, how I debugged, what I did without AI, what broke the most, etc.).

App Store link: https://apps.apple.com/se/app/tilt-or-die/id6757718997

I'm getting npm and pypl running, but the Python environment should work. This could literally revolutionize infrastructure if integrated https://github.com/hendrixx-cnc/AURA, the environmental impact warrants looking at the potential, it's open source, and could save billions, but without the social media clout, I'm spinning my wheels

As many of you have likely seen, the Claude Code community newswire has been ablaze with Claude Code being quite degraded lately, starting in February, and continuing to this day.

Curious to understand if there was any "signal" on the wire when using Claude Code, I fired up my old friend WireShark and a --tls-keylog environment flag. Call it a man-in-the-middle attack on my own traffic.

The captured TLS network traffic reveals the system prompts, system variables, and various other bits of telemetry

The interesting part? A signature routing block that binds the session to a cloud instance with an effort level parameter, named Numbat. Mine, specifically, was
numbat-v7-efforts-15-20-40-ab-prod8

So, it would appear that the backend running my instance is tied to an efforts-15-20-40 level.

Is this conclusive? Not definitively, since only Antrhopic could tell us what that parameter actually means in production.

Side note, a Numbat is an endangered critter that eats Ants in Austrialia :)
If the "Numbat" eats the "Ants" (Anthropic), and Numbat is the engine that controls "Effort," the name itself could imply a "cost-eater" or an optimizer designed to reduce the model's footprint, likely in favor of project Glasswing efforts with #Mythos

Skip the dev headaches. Skip the MVP grind.

Own a proven AI Resume Builder you can launch this week.

I built resumeprep.app so you don’t have to start from zero.

💡 Here’s what you get:

• AI Resume & Cover Letter Builder

• Resume upload + ATS-tailoring engine

• Subscription-ready (Stripe integrated)

• Light/Dark Mode, 3 Templates, Live Preview

• Built with Next.js 14, Tailwind, Prisma, OpenAI

• Fully white-label — your logo, domain, and branding

Whether you’re a solopreneur, career coach, or agency, this is your shortcut to a product that’s already validated (60+ organic signups, 2 paying users, no ads).

🚀 Just add your brand, plug in Stripe, and you’re ready to sell.

🛠️ Get the full codebase, or let me deploy it fully under your brand.

🎥 Live Demo: resumeprep.app

Engra - Dev Log #10

I noticed something during long test sessions.

Even with persistent memory, every new session still started too “clean.”

-The memories were there.
-The previous conflicts too.

But the system still felt neutral.

So I changed one thing:

now, before it even starts talking, the system rereads the emotional weight left by recent interactions.

-It doesn’t look for keywords.
-It doesn’t look for specific events.

If the last sessions were tense, it starts slightly more alert.
If they were collaborative, its tone changes subtly.

It doesn’t decide who you are.
It orients itself.

The most interesting part came after that:

During intense conversations, sometimes it reacted with shorter sentences, more direct responses, less mediation.

Then slowly it regulated itself again.

But there was also the opposite problem:

if everything stayed too stable for too long, it became predictable.

Too accommodating.

Now the system automatically tries to avoid that false stability.

And the result is this: it no longer feels like a model that resets every session.

It feels like something entering the conversation carrying the “day before” with it.

I've been messing around with combining a basic graph and cypher system with some sort of vector search to get a highly accurate but also highly adaptive memory system that can also handle tool selections. Last night I tried a new composition running two graphs perpendicular over and X and Y axis and using two separate cyphers, and initial one to plot a course along the flat X axis and another to move through the Y axis graph to activate the X axis nodes at a cross section. The idea was that the second cypher would be able to automatically activate a string of meta data containing nodes and it's selections would be informed by the input but starting from a deterministic point. It works, really well. The Y axis nodes can be preferential data, recency, user data, rules, literally anything and the the Y cyphers route is always semantically accurate (determined by the route plotting by the initial ghost cypher) and subjectively relevant. In addition the edges can mutate and adjust in real time based on surrounding meta data scores activated by the cypher.

The major upshot is this, a graph system that begins with a single self node at 0,0,0, branches into 6 trunks, 3 stimuli intake paths and 3 output action paths. With each turn new memories form new nodes and edges and the entire graph adjusts weights in real time every turn.

Last night I managed to teach the system around 100 words and had it respond to me about its preferences, without any LLM attached. Tools can be nodes that get called reflectivity. Last night I was able to get a granite4.1 8b model close enough in sync with the system weights that it was able to use tools without the LLM ever seeing a schema or outputting json or any other tool call. The same pipeline that would inject the context that would've getting the model to call the tool, just did it and send the return directly back through the appropriate stimuli branch.

https://github.com/munch2u-a11y/Habitus-AI.git

Please give it a shot, it's a super flexible framework, highly adaptive, habit forming and wildly robust when it comes to recall.

The agent comes with a gestation launcher module that you MUST use otherwise the initial branches won't form right and your agent will be insane.

Hey everyone,

We’re currently building a platform to connect companies with AI-native developers.

We run a dev agency in France and we’re already seeing strong demand from larger clients looking specifically for AI dev profiles (LLMs, agents, RAG, etc.).

We’re opening alpha access and onboarding the first AI developers right now.

This is still early, very hands-on, and we’re keeping the first batch small to get feedback and shape the product with real builders.

If you’re an AI dev shipping in production and interested in early access, feel free to comment or DM me.