• 2 Posts
  • 82 Comments
Joined 1 month ago
cake
Cake day: May 14th, 2026

help-circle



  • Are you asking a technical question or a moral question?

    Pragmatically - IDGAF. If I have it on the ssd, I’ll watch it there. If I need to download from torrent or usenet and then watch it, cool. If it’s easier to use CloudStream (for some transient series), no problem.

    I tend to keep a corpus of movies / shows on my ssd because it’s always there, always reliable, always fast. I have stuff that’s just not easy to find online any more and multi-tenancy / bandwidth are no issue. I can throw it in my bag and watch it wherever, even without net.

    It’s also agnostic. Not every pirate streaming app works on every device. OTOH, samba share / sftp pretty much does. Tonight I streamed stuff onto a OLPC X-O4…good luck getting fmhy to work with that - it can’t even load YouTube directly but stream stuff off the router just fine.

    I don’t use JF much any more (prefer ssd plugged directly into router, accessed via NovaPlayer on android devices; files uploaded to via ftp transfer - yes, very 2010) but I think its pretty amazing. Cloudstream and fmhy are amazing too. Use what works.


  • Cmon now…leaving Agents.md in the repo is bush-league :)

    You can bet your bottom dollar if the claude.md or agents.md hasn’t been added to the gitignore, then it’s -

    1. intentional

    2. actual slop (which you can more easily tell in 2 seconds of looking at the readme.md)

    didn’t say it has to be a tag, what I had in mind was a simple disclosure in the post description explaining how you used AI

    Same issue before though, be the actual disclosure a tag or a statement.

    I do take issue with inexperienced developers that create privacy related software without proper knowledge of what their code actually does (AKA vibe-coding) and going around promoting it as “privacy-friendly” and “secure” while that may not be the case.

    Slop is galling for sure but if we’re talking about trust…well…why trust anyone based on what they say (or don’t say)?

    “Trust but verify” means I still verify. If the thing is mission critical or important to you, then you SHOULD verify, always. Hell, if the threat profile is high, sandbox it and sniff the packets it sends.

    Personally, I think you having to look at the porn I look at is sufficient punishment for snooping on me :)

    Some of this is social engineering. “I have nothing I want to show” works even better when I literally can’t (because X isn’t on my phone or Y doesn’t run on my PC)

    Maybe there are better ways to go about this though, which is partly why I created this post.

    I think so.

    Beyond the obvious slop (which is exceedingly obvious), you’re going to waste a lot of cognitive bandwidth trying to sniff out AI.

    May as well assume AI is used by default and then do the due diligence on the privacy aspects that are of concern to you.

    That holds true whether the project is hand coded or AI assisted. If it’s important, poke it.

    Assume all software is “guilty until proven innocent”

    But please don’t fall into the FuckAI mindset because llm=bad.

    Most devs aren’t going to perform contrition for AI use to appease vocal minority. They’re just not. There’s no up side for them and it reads desperate.

    I’m happy to tell you if asked because IDGAF if you use my shit or not. If I’m sharing it, it’s free, open source and shared out of love. I have no brand or portfolio I’m trying to boost. If you can’t see the USP, it’s probably not for you - and that’s fine.

    It also usually means I made it for me first, so I’m probably not out to steal bitcoin or nudes. Still, do your own due diligence and poke it. I would.


  • OK, seeing you asked for pushback.

    TL;DR: Tool disclosure is a poor proxy for doing your own due diligence.

    “Forced disclosure about AI use in projects” sits sorta funny for a privacy based group, doesn’t it? Kinda “Papers, please”. Smells bad.

    How would you even verify “did this project use an LLM” anyway? If I don’t disclose, what’s the back up, pistols at dawn? Read the code (if available), or get a third party checker…like an LLM? Do you have capacity to audit? Or is it just “trust me, bro” (which if you’re actually concerned about due diligence, isn’t enough).

    More to the point: disclosure tag doesn’t change whether the code is accurate, safe or good. Shitty code is shitty either way, so the tag doesn’t touch the actual harm you’re concerned about.

    What it does do is create two classes: labeled projects get extra scrutiny, unlabeled ones get a free pass, “no disclosure, must be hand-written, must be fine.” Backwards. Honest disclosure gets tarnished as slop, staying quiet gets rewarded. (Go check !self hosted right now for such an occurrence).

    Better footing: assume ALL software in 2026 has had AI assistance, and review it on its merits.

    There are better quality signals than hand on bible “are you now or have you ever been” oaths or performative humiliation for the FuckAI crowd.

    For what it’s worth, I use an LLM to write code because I’ve got osteoarthritis and typing all day isn’t free. But if you think that means logging into Claude and telling it “make this for me, no mistakes”, you couldn’t be more wrong.

    I define the project, I pseudo code it with pen and paper (hurts my hands less) I scope every ticket (yes, I make the llm go thru 3 stage ticket review), I review outputs, I smoke test and I even call in outside reviewers to spot check sometimes. I’m an absolute bastard to it in QA. I do that because when I’m done, I can stand in front of it and honestly tell you I made this, even if my fingers didn’t type most of it. And if it’s fucked, that’s on me, not “hallucinations”.

    So, what box do I tick - “AI-assisted”? “Vibe slop”?

    That tells you nothing about who’s accountable or how it was made. It carries no nuance and silently resolves to “ignore this one, a robot wrote it,” … which is backwards for projects where the human did more QA than most “fully human” teams ever do.

    As always, ICBW and YMMV.












  • Perfect. Then my third suggestion stands - get it make you a bespoke training module.

    Create a project container: upload the source documents already cited by others / ones you find useful. Just 4 or 5.

    Add the rule “You are helping me learn ____. You must not provide full refactors unless specifically asked for. Use Socratic method where appropriate”.

    Pseudo code what you want to do (hell, draw a flow chart) and ask “based on what I want to do, your background knowledge and the contents of the container, what’s the first thing I need to learn? How should I approach this?”

    Then ask “why?”

    Hell, get it to make you coding exercises.

    After each session, get it to make you a handover note in markdown format. Download it and then add that to your container. (Later on, you can get really fancy and start making your own llm-wiki)

    People shit on LLMs as a knee jerk thing… but coding IS a language…and if you understand the logic, the rest is syntax. Also, it’s not as if you’re making some million dollar mission critical thing- you’re teaching yourself through successive approximation.

    If you don’t feel comfortable using online models, there are even local alternatives.

    I still think JavaScript is the faster way for this, but who knows.



  • Scoping first, code ideas at bottom. Kewl?

    Is this a “learn it by coding it” project or is it a “I want this thing to exist, no one has done it, but my code skills aren’t quite there” project?

    If the latter, would you consider iterating via llm (as you mention n8n, so I figure you’re in that space anyway) or is this a purely a learn by doing thing?

    Come to think of it, there is actually a third option here. You could get the LLM to teach you how to code it by writing some pseudo code and asking it for pointers / starting steps. Claude web is pretty good for that sort of thing, I think. You can get it to tailor its lessons to what you need without the tedium of starting at “Hello World”.

    You seem like the sort that could keep that interaction honest and not let it just do everything.

    PS: I read about your setup - sounds brilliant. Go you good thing.

    PPS: n8n has a Code node (JavaScript), and parsing that weather JSON into a formatted string is probably like 15 lines of code. Something like -

    const data = $input.first().json;

    return [{ json: { temperature: data.list[0].main.temp } }];

    add a Code node after your HTTP request in n8n. Get one single value out first. If you see a temperature number in the output, you win.

    Pulling Python in just to parse JSON is probably adding a tool you don’t need for this.

    JavaScript may be ass but it’s literally there, so it’s omnipresent ass. :)

    Once you’ve got the JSON parsed, turn it into one small HTML weather card.

    const data = $input.first().json; const item = data.list[0];

    const html = <div> <h3>Weather</h3> <p>Current temperature: ${item.main.temp} °C</p> <p>Feels like: ${item.main.feels_like} °C</p> <p>Humidity: ${item.main.humidity}%</p> <p>Condition: ${item.weather[0].description}</p> </div>;

    return [{ json: { html } }];

    (Sorry about the formatting ; Lemmy formatting is weird AF)

    Anyway, as one journeyman to another, that’s where I’d start poking. ICBW.


  • Let’s tag it as “provisional” then. As in, once you have my provisional trust, accrued over time, I’ll probably stop auditing every single line. I’ll still look tho.

    But the long and short of it is this - XZ utils backdoor actually makes case for trusting clankers more than human collaborators. Clankers are incompetent… they usually aren’t Machiavellian.

    I’ve heard it said that an LLM is like a Labrador retriever when it comes to coding. Overly excited, pulls ahead, does some really goofy shit and sometimes chews up your couch (hello Qwen 27B)…but it is trainable.

    Human devs are like cats…which is oddly on brand for this project :)

    I’d sooner trust a clanker I had prompted with my house style ticket and narrowly sandboxed than a rando online. Of course, the difference is, a rando may eventually earn trust…a clanker doesn’t - but it doesn’t need to if narrowly scoped.

    EDIT: here’s a template I use / created for Qwen / Codex. It’s…opinionated and bears scars of prior over eager Labradors. This is usually step 1 I fill out. My fingers are going to shit with O/A , so am trying to minimise scut work.


    TICKET-Px-SHORT-DESCRIPTIVE-NAME

    Status: PROPOSED Timestamp: DD-MM-YY-HH-MM Priority: P0 | P1 | P2 | P3

    Purpose

    One paragraph:

    • what changes
    • what does not
    • whether this is proposal / proof / implementation

    Why this exists

    Describe:

    • concrete failure mode
    • why current behaviour is wrong
    • why this is architectural not cosmetic
    • why local patches are rejected

    Include: We do not want … We do want …

    Proof requirements before implementation

    Hard gate.

    Before implementation exists, prove:

    • seam exists
    • ownership is correct
    • contract can be enforced
    • no god-object expansion
    • no hidden coupling

    If proof fails: stop and escalate. Do not patch.

    Gates

    • Step 0 GO/NO GO
    • Step 1 GO/NO GO
    • Step 2 GO/NO GO
    • Step N GO/NO GO

    Each gate:

    • exact thing being proven
    • explicit stop condition

    Test Plan

    Mix of:

    • unit fixtures
    • regression replay
    • smoke coverage
    • edge cases
    • negative cases

    Prefer: prove behaviour changed, not just coverage increased.

    Definition of Success / PASS

    Minimum acceptable state.

    Must describe:

    • observable outcome
    • old failure closed
    • contract enforced
    • ownership preserved

    Definition of Success / EXCELLENT

    Stretch target.

    Usually:

    • generalises across adjacent lanes
    • demonstrates reuse
    • proves contract not logging theatre

    Assumptions

    State assumptions explicitly.

    Examples:

    • baseline already proven
    • implementation surface bounded
    • no broad whitelist/regex fix

    Proposed shape

    Describe:

    • modules
    • packets/cards/contracts
    • ownership boundaries
    • interfaces

    Prefer: small typed objects.

    Thin leaf intent

    If adding logic:

    prefer:

    • thin leaf
    • compact return object
    • narrow ownership

    Avoid:

    • diagnostic fluff
    • local maxima

    Policy versus signal

    Policy: config

    Signal: code

    Config controls behaviour. Signal detects reality.

    Scope

    Explicitly include:

    • what this ticket covers

    Non-goals

    Explicitly exclude:

    • unrelated cleanup
    • opportunistic refactors
    • god-object growth
    • broad routing changes

    Acceptance criteria

    Numbered list.

    Must be testable.

    Definition of done

    Agreement on:

    • ownership
    • interfaces
    • config surface
    • enforcement point

    Only then may implementation tickets follow.