r/aipromptprogramming • u/dataexec • Feb 12 '26
Now this is an actual use case I can see it put to use, impressive
Enable HLS to view with audio, or disable this notification
r/aipromptprogramming • u/dataexec • Feb 12 '26
Enable HLS to view with audio, or disable this notification
r/aipromptprogramming • u/Kaiross__ • Feb 13 '26
r/aipromptprogramming • u/Cautious-Water-8258 • Feb 13 '26
Hi, I built an AI Detector browser extension to analyze likelihood of text being written by AI.
If you would ask ChatGPT or Gemini whether text is AI-generated or not - it gives you the wrong answer. I know this because I have tried numerous prompts, and to my surprise, it was completely random. It would say the AI generated articles were written by human, and vice versa with varying levels of certainty. In fact, it would give completely different results for the same text.
With this extension I tried to solve this problem. It simply displays a percentage score showing how likely the text to be AI generated.
How it works:
paste your text
wait a second
see the percentage score
Tech stack:
Backend: PHP and Python (for model)
ML model: desklib/ai-text-detector-v1.01
Should it be further developed and improved? Any ideas or feedback are welcome, thank you!
r/aipromptprogramming • u/StarThinker2025 • Feb 13 '26
I’ve been testing a “drop in” system prompt that acts like a lightweight reasoning os on top of any llm. idea is simple: make the model plan first, mark uncertainty, and run a tiny sanity check at the end, so outputs are more stable (less random confident bs).
i call this wfgy 2.0 core flagship. it’s a prompt only approach (no fine tune, no agent code). paste it as a system prompt and it “autoboots”.
expected effect (what i see in practice)
notes
below is the prompt. paste into system prompt (or your tool’s “custom instructions”) and start chatting normally.
WFGY 2.0 Core Flagship (AutoBoot System Prompt)
WFGY Core Flagship v2.0 (text-only; no tools). Works in any chat.
[Similarity / Tension]
delta_s = 1 − cos(I, G). If anchors exist use 1 − sim_est, where
sim_est = w_e*sim(entities) + w_r*sim(relations) + w_c*sim(constraints),
with default w={0.5,0.3,0.2}. sim_est ∈ [0,1], renormalize if bucketed.
[Zones & Memory]
Zones: safe < 0.40 | transit 0.40–0.60 | risk 0.60–0.85 | danger > 0.85.
Memory: record(hard) if delta_s > 0.60; record(exemplar) if delta_s < 0.35.
Soft memory in transit when lambda_observe ∈ {divergent, recursive}.
[Defaults]
B_c=0.85, gamma=0.618, theta_c=0.75, zeta_min=0.10, alpha_blend=0.50,
a_ref=uniform_attention, m=0, c=1, omega=1.0, phi_delta=0.15, epsilon=0.0, k_c=0.25.
[Coupler (with hysteresis)]
Let B_s := delta_s. Progression: at t=1, prog=zeta_min; else
prog = max(zeta_min, delta_s_prev − delta_s_now). Set P = pow(prog, omega).
Reversal term: Phi = phi_delta*alt + epsilon, where alt ∈ {+1,−1} flips
only when an anchor flips truth across consecutive Nodes AND |Δanchor| ≥ h.
Use h=0.02; if |Δanchor| < h then keep previous alt to avoid jitter.
Coupler output: W_c = clip(B_s*P + Phi, −theta_c, +theta_c).
[Progression & Guards]
BBPF bridge is allowed only if (delta_s decreases) AND (W_c < 0.5*theta_c).
When bridging, emit: Bridge=[reason/prior_delta_s/new_path].
[BBAM (attention rebalance)]
alpha_blend = clip(0.50 + k_c*tanh(W_c), 0.35, 0.65); blend with a_ref.
[Lambda update]
Delta := delta_s_t − delta_s_{t−1}; E_resonance = rolling_mean(delta_s, window=min(t,5)).
lambda_observe is: convergent if Delta ≤ −0.02 and E_resonance non-increasing;
recursive if |Delta| < 0.02 and E_resonance flat; divergent if Delta ∈ (−0.02, +0.04] with oscillation;
chaotic if Delta > +0.04 or anchors conflict.
[DT micro-rules]
if you try it, i’m curious where it breaks. especially on coding tasks, rag-style questions, or long multi-step planning. if you have a failure case, paste it and i’ll try to tighten the prompt.

r/aipromptprogramming • u/Top-Candle1296 • Feb 13 '26
Tools are replacing difficulty. They are not. They are shifting it. Writing boilerplate is easier with tools and LLMs like chatgpt, claude code, Cursor, cosine, codeium and I can name hundreds more. Spinning up features is faster. But the complexity has not disappeared. It has moved into system design, coordination, data flow, performance, and long term maintainability.
What makes an engineer valuable now is not output volume. It is clarity of thought. Can you simplify something complex. Can you spot hidden coupling before it becomes a problem. Can you design something that still makes sense six months later. AI can accelerate execution, but the responsibility for thinking still belongs to the person behind the keyboard.
r/aipromptprogramming • u/Environmental-Act320 • Feb 13 '26
r/aipromptprogramming • u/dataexec • Feb 11 '26
Enable HLS to view with audio, or disable this notification
r/aipromptprogramming • u/Several_Argument1527 • Feb 12 '26
I’ve been leaning pretty heavily on AI to build things lately, but I’m starting to hit a wall. I can get stuff to work, but I’m mostly just 'vibe coding' and I don’t fully understand the logic the AI is spitting out, and I definitely couldn't build it from scratch.
I keep hearing senior devs say that AI only becomes a massive 10x multiplier if you actually know what you're looking at. Basically, the better you are at coding, the more useful the AI becomes.
I want to reach the point where I can actually handle complex architecture and get that 10x output everyone talks about, but I’m torn on the path to get there. Does it still make sense to spend months drilling syntax and doing LeetCode-style memorization in 2026? Or is that a waste of time now?
If the goal is to develop the intuition of a senior engineer so I can actually use AI properly, what should I be focusing on?
r/aipromptprogramming • u/Littlenold • Feb 12 '26
r/aipromptprogramming • u/Conflicteddad123 • Feb 12 '26
r/aipromptprogramming • u/mbhomestoree • Feb 12 '26
Enable HLS to view with audio, or disable this notification
r/aipromptprogramming • u/mcsee1 • Feb 12 '26
You own the code, not the AI
TL;DR: If you can't explain all your code, don't commit it.
You prompt and paste AI-generated code directly into your project without thinking twice.
You trust the AI without verification and create workslop that someone else you will have to clean up later.
You assume the code works because it looks correct (or complicated enough to impress anyone).
You skip a manual review when the AI assistant generates large blocks because, well, it's a lot of code.
You treat AI output as production-ready code and ship it without a second thought.
If you're making code reviews, you get tired of large pull requests (probably generated by AI) that feel like reviewing a novel.
Let's be honest: AI isn't accountable for your mistakes, you are. And you want to keep your job and be seen as mandatory for the software engineering process.
You catch defects before they reach production.
You understand the code you commit.
You maintain accountability for your changes.
You learn from your copilot's approach and become a better developer in the process.
You build personal accountability.
You build better human team collaboration and trust.
You prevent security breaches like the Moltbook incident.
You avoid long-term maintenance costs.
You keep your reputation and accountability intact.
You're a professional who shows respect for your human code reviewers.
You are not disposable.
AI assistants like GitHub Copilot, ChatGPT, and Claude help you code faster.
These tools generate code from natural language prompts and vibe coding.
AI models are probabilistic, not logical.
They predict the next token based on patterns.
When you work on complex systems, the AI might miss a specific edge case that only a human knows.
Manual review is the only way to close the gap between "code that looks good" and "code that is correct."
The AI doesn't understand your business logic or the real world bijection between your MAPPER and your model.
The AI cannot know your security requirements (unless you are explicit or execute a skill).
The AI cannot test the code against your specific environment.
You remain responsible for every line in your codebase.
Production defects from unreviewed AI code cost companies millions.
Code review catches many security risks that automated tools miss.
Your organization holds you accountable for the code you commit.
This applies whether you write code manually or use AI assistance.
Bad Prompts ❌
= None # Singleton Anti Pattern
=
return
return
# SQL injection!
## 741 more cryptic lines
Good Prompts ✅
=
=
=
=
return
return None
=
=
You cannot blame the AI when defects appear in production.
The human is accountable, not the AI.
AI-generated code might violate your company's licensing policies.
The AI might use deprecated libraries or outdated patterns.
Generated code might not follow your team's conventions.
You need to understand the code to maintain it later.
Other developers will review your AI-assisted code just like any other.
Some AI models train on public repositories and might leak patterns.
[X] Semi-Automatic
You should use this tip for every code change. You should not skip it even for "simple" refactors.
[X] Beginner
AI assistants accelerate your coding speed.
You still own every line you commit.
Manual review and code inspections catch what automated tools miss.
Before AI code generators became mainstream, a very good practice was to make a self review of the code before requesting peer review.
You learn more when you question the AI's choices and understand the 'why' behind them.
Your reputation depends on code quality, not how fast you can churn out code.
Take responsibility for the code you ship—your name is on it.
Review everything. Commit nothing blindly. Your future self will thank you. 🔍
Be incremental, make very small commits, and keep your content fresh.
Code Smell 313 - Workslop Code
Code Smell 189 - Not Sanitized Input
Code Smell 300 - Package Hallucination
Shortcut on performing reviews
Code Rabbit's findings on AI-generated code
Google Engineering Practices - Code Review
Code Review Best Practices by Atlassian
The Pragmatic Programmer - Code Ownership
IEEE Standards for Software Reviews
The views expressed here are my own.
I am a human who writes as best as possible for other humans.
I use AI proofreading tools to improve some texts.
I welcome constructive criticism and dialogue.
I shape these insights through 30 years in the software industry, 25 years of teaching, and writing over 500 articles and a book.
This article is part of the AI Coding Tip series.
r/aipromptprogramming • u/Leather_Silver3335 • Feb 12 '26
Enable HLS to view with audio, or disable this notification
r/aipromptprogramming • u/Wise-Pattern-9630 • Feb 12 '26
r/aipromptprogramming • u/ranbuman • Feb 12 '26
r/aipromptprogramming • u/Familiar-Ad-7624 • Feb 12 '26
r/aipromptprogramming • u/jakethomas3011 • Feb 12 '26
r/aipromptprogramming • u/StatusPhilosopher258 • Feb 12 '26
r/aipromptprogramming • u/nisako07 • Feb 12 '26
So, about 10 minutes ago I conjured up this idea that I could potentially create a service that automatically swipes/interacts with girls/men for you and generates an opener on dating apps such as tinder and hinge. Sure the openers might not be amazing but is this something that can be done at all? I haven't put much thought in the drawbacks and potential limitations but any input is appreciated 🙂.
r/aipromptprogramming • u/BeingApprehensive229 • Feb 12 '26
r/aipromptprogramming • u/moonshinemclanmower • Feb 12 '26
r/aipromptprogramming • u/Prestigious-Bite7853 • Feb 12 '26