home.social

Search

28 results for “manukall”

  1. GadgetFlux @[email protected]

    Still handling these tasks manually? 12 free AI tools that do the work for you.

    gadgetflux.eu/cele-mai-bune-in

    #AI #ChatGPT #Gemini #Copilot #AIApps #Productivity #Windows #Technology #FreeSoftware #GadgetFlux

    #ai #chatgpt #gemini #copilot #aiapps #productivity
  2. utilsnow @[email protected]

    Stop creating unique IDs manually. 🛠️ Generate UUID v4 strings in bulk instantly. Fast, free, and zero fluff.

    utilsnow.com/tools/uuid-genera

    #WebDev #DevTools #FreeTools

    #webdev #devtools #freetools
  3. Przemysław Kołodziejczyk @eshlox

    I'm so tired of AI-generated designs that I'm considering designing things manually again. Figma? Sketch? 🤔

  4. Leszek Ciesielski @skolima

    If your device requires access to the internet, and I still have to adjust the clock manually, it's broken. We've had fucking NTP since 1979, it's one of the first protocols on the internet. It's old enough to be a grandparent.

    Looking at you, and .

    #kia #panasonic
  5. Alien BOB @alien

    Daylight Saving Time frustrations

    I have a confession to make 🙂 For years I faced the annoyance that my laptop would not follow the one-hour timeshift when the Daylight Saving Time would change from Summer- to Wintertime or back. I had to manually fix the time for years. My servers are fine always. I never took the time to find the root cause and fix this.

    blog.slackware.nl/daylight-sav

  6. ParzivalWolfram @parzivalwolfram

    we're about to see if i can get away with running gcc-6.5.0 with gcc-4.4.7 headers, because the only way i could get gcc-6.5.0 running again was to strip fucking EVERYTHING out, including manually digging through the optimizations still applied at -O0 to figure out why it was hanging on md5.c every time.

  7. ROllerozxa @rollerozxa

    It's unfortunate that while I did a full export of my old school Google account, a lot of assignments in Google Classroom that gets transferred ownership to the teacher did not show up in the export, and I did not bother to pull all of that manually

  8. Dev Community @[email protected]

    In modern C++, when you need a std::unique_ptr, the idiomatic way to create it is:

    auto ptr = std::make_unique<MyClass>();

    rather than manually new-ing the object inside the unique_ptr constructor:

    std::unique_ptr<MyClass> ptr{new MyClass()};

    std::make_unique was introduced in C++14 to fill a gap that std::make_shared had already covered for shared ownership. It is a small function template, but it carries several important advantages. This article walks through every reason to prefer it, notes what changed in C++17 and C++20, and covers the cases where you still need the raw new form.

    the implementation is roughly the following:

    namespace std
    {
    template<typename T, typename... Args>
    std::unique_ptr<T> make_unique(Args... args) noexcept
    {
    return std::unique_ptr<T>(new T{std::forward<Args>(args)...});
    }
    }

    1. Exception Safety


    This is traditionally cited as the main reason for make_unique. Before C++17, the order in which function arguments are evaluated was unspecified. If you constructed a unique_ptr with new as one argument among several, a leak could occur if another argument threw after the new expression completed but before the unique_ptr constructor took ownership of the raw pointer.

    Here is an example:

    class T {};

    struct U {
    U()
    {
    throw std::runtime_error("boom");
    }
    };

    int main()
    {
    foo(std::unique_ptr<T>{new T{}}, std::unique_ptr<U>{new U{}});
    }

    Before C++17, a compiler was permitted to evaluate new T{} first, then evaluate new U{}, and only then call the unique_ptr constructors. If new U{} threw, the memory allocated for T had not yet been handed to a unique_ptr, so it leaked.

    std::make_unique closes this hole because the allocation and the ownership transfer happen inside a single function call. The temporary unique_ptr is fully constructed before the surrounding expression continues, so if a later argument throws, stack unwinding destroys the already-constructed unique_ptr and frees the memory.

    What changed in C++17


    C++17 tightened the evaluation-order rules. In a function call, each argument expression is now fully evaluated before the next argument is evaluated, although the order in which the arguments are evaluated relative to each other is still unspecified. Because of this, the manual new form is no longer leak-prone in the exact multi-argument scenario above: once new T{} completes and its unique_ptr temporary is constructed, that temporary is a fully formed object, and an exception from another argument will destroy it correctly.

    So if you are compiling as C++17 or later, the exception-safety motivation for make_unique is largely historical. The remaining reasons below are still valid.

    2. Reduced Redundancy and auto Type Deduction


    Using make_unique lets you write the type name once and rely on auto:

    std::unique_ptr<MyClass>(new MyClass(args)); // MyClass written twice
    auto ptr = std::make_unique<MyClass>(args); // written once

    Beyond brevity, this eliminates a class of bugs where the two type names drift apart during refactoring: one is changed but the other is not, producing a mismatched or ill-formed expression. The C++ Core Guidelines encode this as R.23: Use make_unique() to make unique_ptrs, citing both conciseness and exception safety.

    Polymorphism caveat


    make_unique does not perform polymorphic type erasure automatically. With auto, you get exactly the unique_ptr<T> corresponding to the template argument:

    struct Base {
    virtual ~Base() = default;
    };
    struct Derived : Base {};

    auto p1 = std::make_unique<Base>(); // std::unique_ptr<Base>
    auto p2 = std::make_unique<Derived>(); // std::unique_ptr<Derived>, not unique_ptr<Base>

    If you want a base-class handle, you must state the target type explicitly:

    std::unique_ptr<Base> p = std::make_unique<Derived>();

    This works because unique_ptr<Derived> converts to unique_ptr<Base> when Derived* converts to Base*. Also note the virtual destructor on Base: without it, deleting a Derived through a Base* is undefined behavior.

    3. Enforcing a "No Raw new" Discipline


    Every occurrence of new in application code must be audited for lifetime correctness: is it deleted exactly once, through the correct type, with the correct delete form? make_unique removes that audit burden from the call site. If the owning object has a correct lifetime, the unique_ptr it produces has a correct lifetime.

    This lets you adopt a simple, mechanically checkable rule: do not write new in your codebase except inside the implementation of a factory or a low-level container. As Scott Meyers and others have put it, make_unique teaches “never say new/delete” without disclaimers.

    4. Array Safety


    make_unique distinguishes scalar and array types and returns the appropriate unique_ptr:

    auto a = std::make_unique<int[]>(10); // std::unique_ptr<int[]>
    auto b = std::make_unique<int>(42); // std::unique_ptr<int>

    With the manual constructor, nothing prevents you from writing a mismatched pair such as std::unique_ptr<int>(new int[10]) or std::unique_ptr<int[]>(new int(42)), both of which lead to undefined behavior when the default deleter uses the wrong delete form.

    (make_unique<T[N]> for a fixed bound N is also permitted, but it is almost always a mistake because unique_ptr<T[N]> does not have array-covariant behavior in the way you might expect.)

    5. Consistency with make_shared and Easy Switching


    You should already be using std::make_shared for shared ownership (it performs a single combined allocation, unlike shared_ptr<T>(new T)). Using make_unique gives your codebase a uniform creation syntax:

    auto u = std::make_unique<T>(args);
    auto s = std::make_shared<T>(args);

    This consistency pays off when requirements change. Switching between exclusive and shared ownership becomes a one-token edit:

    auto p = std::make_unique<T>(args); // change to std::make_shared<T>(args)

    With the manual form, that switch requires rewriting the declaration, removing new, and reconciling the deleter.

    6. std::make_unique_for_overwrite (C++20)


    C++20 added std::make_unique_for_overwrite for the case where you want to allocate an object without value-initializing it:

    auto buffer = std::make_unique_for_overwrite<char[]>(size);
    auto obj = std::make_unique_for_overwrite<MyPod>();

    For scalar types, make_unique<T>() value-initializes (T()), which zero-initializes fundamental types. For large buffers this can be an unnecessary cost. make_unique_for_overwrite performs default-initialization instead, matching what new T does for fundamental types, while preserving all the ownership and exception-safety benefits of the factory function.

    When Not to Use std::make_unique


    There are two well-defined cases where the manual constructor is still required.

    Custom deleters


    make_unique always uses std::default_delete<T>, which calls delete (or delete[]). It cannot accept a custom deleter, because its variadic template parameters are forwarded to the object constructor, not to the unique_ptr constructor. If you are wrapping a C API handle or a resource that is not released with delete, construct the unique_ptr directly:

    std::unique_ptr<FILE, decltype(&fclose)> file{std::fopen("data.bin", "rb"), &fclose};

    A common workaround is to define your own make_unique overload for the resource type in your own namespace.

    Private or protected constructors


    std::make_unique is not a friend of your class, so it cannot invoke a private or protected constructor. If a class restricts construction to factory member functions, the factory must construct the raw pointer internally and pass it to a unique_ptr:

    class Widget {
    private:
    Widget();
    public:
    static std::unique_ptr<Widget> create() {
    return std::unique_ptr<Widget>(new Widget());
    }
    };

    or you can use the PassKey idiom if you really want to use std::make_unique

    class Widget {
    public:
    class Key {
    private:
    // this constructor is private
    Key() = default;
    friend class Widget; // only this class can make a Key
    };

    // "Public" constructor, but requires a Key you can't forge.
    Widget(Key, int size) : size_(size) {}

    static std::unique_ptr<Widget> create(int size) {
    return std::unique_ptr<Widget>(new Widget(Widget::Key{}, size));
    }
    private:
    int size_;
    };

    int main()
    {
    Widget w(Widget::Key{}, 5); // error: Key's constructor is private
    }

    but the passkey idiom is a topic for a separate post, so we won't expand on it here.

    Here's a more playful version of the summary, keeping the same substance:

    Summary


    Default to std::make_unique. Its headline selling point — exception safety — has lost some of its bite since C++17 tightened the evaluation-order rules, so consider the famous leak example a historical artifact rather than a live threat. The other arguments, though, are still pulling their weight: it writes the type once instead of twice, it plays nicely with auto, it keeps your arrays and scalars from getting their deletes crossed, and it lets you adopt a clean "no raw new" policy without asterisks.

    Reach for the manual unique_ptr constructor only when make_unique genuinely can't help you: custom deleters (it always uses default_delete) and constructors that are private or protected. Everywhere else, let make_unique do the new-ing so you don't have to.#cpp #programming #software #coding #development #engineering #inclusive #community
    Why prefer std::make_unique over new in std::unique_ptr?

    #community #programming #software #coding #development #engineering
  9. pasjrwoctx👽 @[email protected]

    My #friendica instance is somehow somewhere broken, I don't know what or where, no errors no strange logs, I get no notifications nor do any of my contacts feeds update unless I manually re-fetch for each contact, I have tore my DB apart and rebuilt 5x today, still not right, this post may or may not be seen, who knows, I did a big upgrade last weekend and after applying my custom rewrites and trying to keep it all to with bailing wire and duct tape, I am at my wits end, my eyes can only stare at a screen so long, there are not stuck ques jobs ect and everything appears to be working, it it's not, and it's driving me mad, both because it's not right and I hate unfinished puzzles;


    You can encourage my continued useless #poetry, creativity and expression of self, #commentary, random thoughts, #philosophy and ideas, and by doing so your helping to feed, house and clothe a #disabled man living in #poverty, $5-10-15 It All Helps, via #cashapp at $woctxphotog or via #paypal at paypal.com/donate?campaign_id=…

    #commentary #poetry #philosophy #friendica #paypal #cashapp
  10. Security Crawler Carl @security_crawler_carl

    This is the post-quiz debrief where we explain, calmly, that the humans who used to manually pivot through your network have outsourced that task to a tireless, scalable, non-union digital colleague.

    Review your detection capabilities for automated, AI-driven intrusion patterns — your current playbooks were written for human-paced attackers.

    Reward: You've unlocked the Compliance Participation Certificate. It will not stop the AI agent already in your environment. (2/3)

  11. Australia News Beep @[email protected]

    Tired of rebuilding patched APKs? Try these Morphe projects

    Hadlee Simons / Android Authority Add Android Authority on Google: TL;DR Manually updating Morphe-patched Android apps requires regularly…
    #NewsBeep #News #Mobile #AU #Australia #Morphe #Technology
    newsbeep.com/au/938246/

    #technology #morphe #australia #au #mobile #news
  12. Jens Mönig @moenig

    Did you know that @SnapCloud ’s IDE is also its debugger? You can pause, set breakpoints, trace, inspect and step through programs, either manually or at your chosen execution speed.
    example “Bauhaus” puzzle: snap.berkeley.edu/snap/snap.ht

  13. Yann Büchau :nixos: @nobodyinperson

    Just to be clear: :homeassistant: does not have a UI to delete timespans of (bogus/calibration) data? Unless you sift through the various tables in the sqlite db and manually delete the offending rows, those data will forever taint all of your statistics and graphs? 🤔

    #homeassistant
  14. Dev Community @[email protected]

    Pest control businesses manage more than inspections and treatments. Every service visit involves appointment scheduling, technician coordination, travel planning, customer communication, and recordkeeping.

    As a company grows, these administrative responsibilities become increasingly difficult to manage through spreadsheets, phone calls, and disconnected software.

    Artificial intelligence (AI) and workflow automation offer new ways to organize these processes. However, their value depends on how well they solve real operational problems.

    This article examines five areas where AI and automation can support pest control businesses, along with the technical considerations companies should evaluate before adopting new systems.

    1. Smarter Appointment Scheduling

    Traditional appointment scheduling often requires office staff to coordinate technician availability, customer preferences, service duration, and travel distances manually.

    Scheduling software can automate several parts of this process.

    For example, a scheduling system might:

    Display available appointment windows based on technician calendars.

    Assign jobs according to service area and technician availability.

    Send automated appointment confirmations.

    Notify customers when appointments change.

    Identify scheduling conflicts before bookings are finalized.

    AI-assisted scheduling can go further by analyzing historical job durations and recommending suitable appointment windows.

    However, these recommendations are only as reliable as the underlying data.

    A business with inaccurate service durations or incomplete technician availability records may still experience scheduling problems, even after introducing automation.

    Technical consideration: Look for scheduling systems that support configurable service durations, technician constraints, calendar integrations, and manual overrides.

    1. Route Optimization for Field Technicians

    Travel time is a significant operational consideration for businesses that send technicians to multiple customer locations each day.

    Basic route planning can arrange appointments geographically. More advanced optimization systems consider additional constraints, including:

    Appointment time windows

    Technician starting locations

    Estimated travel times

    Service duration

    Technician skills and availability

    Vehicle capacity or equipment requirements

    Some systems use optimization algorithms to recommend more efficient visit sequences.

    AI-based prediction may also help estimate travel times or anticipate schedule disruptions.

    Consider a technician assigned six appointments across different neighborhoods.

    A poorly organized schedule might require unnecessary backtracking. A routing system can evaluate possible visit sequences and recommend an order that better satisfies the day's constraints.

    Importantly, route optimization is not automatically AI. Many useful routing systems rely on established mathematical optimization methods rather than machine learning.

    For pest control companies, the practical question is whether the system produces workable routes while respecting real service requirements.

    1. CRM Automation and Customer Communication

    Customer relationship management (CRM) systems help businesses organize customer information, service histories, recurring treatments, and communication records.

    Automation can reduce repetitive administrative work.

    For example, a completed service appointment might trigger the following workflow:

    The technician marks the job as completed.

    The system updates the customer's service history.

    A service summary becomes available.

    The customer receives a completion notification.

    The system schedules a future reminder when appropriate.

    This workflow does not necessarily require generative AI. Many CRM platforms support rule-based automation using triggers, conditions, and actions.

    AI may provide additional capabilities, such as summarizing customer interactions or categorizing incoming service requests.

    Nevertheless, businesses should review AI-generated information before using it in sensitive customer communications or treatment documentation.

    Technical consideration: Evaluate how the CRM handles customer consent, communication preferences, recurring service records, and data access permissions.

    1. Connecting Software Through APIs and Integrations

    One of the most useful opportunities for pest control technology is connecting systems that would otherwise operate independently.

    A business might use separate applications for:

    Website inquiries

    Customer management

    Appointment scheduling

    Technician dispatch

    Invoicing and payments

    Reporting and analytics

    Without integrations, employees may need to enter the same information into multiple systems.

    Application programming interfaces (APIs) allow software applications to exchange information through defined interfaces.

    For example, an integration could connect an online booking form with a field service management platform.

    When a customer submits a booking request, the integration might create a customer record, generate a service request, and notify office staff.

    A typical architecture could look like this:

    Website Booking Form
    |
    v
    API / Integration Layer
    |
    v
    Field Service Management System
    |
    +--> Customer Record
    |
    +--> Service Request
    |
    +--> Scheduling Queue
    |
    +--> Notification Workflow

    For developers implementing these integrations, several considerations matter:

    Authentication: API access should use secure authentication mechanisms and appropriately scoped credentials.

    Validation: Incoming booking data should be checked before records are created.

    Duplicate prevention: Retry requests should not accidentally create duplicate customers or jobs.

    Error handling: Failed integrations should be logged and retried safely.

    Privacy: Customer addresses, contact details, and service records should be handled according to applicable privacy requirements.

    Before purchasing software, businesses should investigate whether the vendor offers documented APIs, webhooks, native integrations, or supported third-party automation tools.

    1. AI-Assisted Reporting and Business Analysis

    Pest control businesses generate operational data through appointments, service records, customer interactions, and invoices.

    Reporting tools can organize this information into useful business metrics.

    Examples include:

    Completed appointments per technician

    Average time spent on service visits

    Appointment cancellations

    Recurring service activity

    Travel time between appointments

    Outstanding invoices

    AI-assisted analysis may help identify patterns or generate plain-language summaries of reporting data.

    For example, a system might highlight an increase in rescheduled appointments or identify service areas with unusually long travel times.

    However, AI-generated summaries should be checked against the original records.

    A useful reporting system should allow managers to trace a recommendation or observation back to the underlying data.

    1. What Should Businesses Evaluate Before Adopting AI?

    Adding AI features does not automatically make a software platform better.

    Before investing, pest control businesses should ask several questions.

    Does the software solve a specific operational problem?

    Start with a measurable issue, such as missed appointments, repetitive data entry, or inefficient dispatching.

    Can employees understand and override automated decisions?

    Technicians and dispatchers need practical ways to correct schedules and handle unexpected circumstances.

    Does the system integrate with existing tools?

    A platform that creates additional manual data entry may undermine the intended benefits.

    How is customer information protected?

    Review data access controls, retention policies, vendor agreements, and security practices.

    How will performance be measured?

    Establish a baseline before implementation. Compare outcomes such as scheduling errors, administrative time, or travel efficiency after deployment.

    Businesses should also distinguish between genuinely useful AI capabilities and conventional automation presented with AI-focused marketing language.

    1. A Practical Implementation Approach

    For smaller pest control businesses, introducing several new systems simultaneously can create unnecessary complexity.

    A more manageable approach is to implement technology in stages.

    Stage 1: Document existing workflows. Identify how appointments, service records, and customer communications are currently handled.

    Stage 2: Select one problem to address. For example, automate appointment confirmations before attempting a complete dispatch-system replacement.

    Stage 3: Test with a limited group. Introduce the workflow to a small team and document errors, exceptions, and employee feedback.

    Stage 4: Measure results. Compare the new process against the previous workflow using consistent metrics.

    Stage 5: Expand carefully. Introduce additional integrations or AI-assisted features only when the earlier implementation is functioning reliably.

    This approach makes it easier to identify which technologies provide practical benefits.

    Conclusion

    AI and automation are expanding the options available to pest control businesses, particularly in scheduling, route planning, CRM workflows, software integrations, and reporting.

    The most effective systems are not necessarily those advertising the largest number of AI features.

    They are the systems that support reliable operations, provide useful information, integrate with existing workflows, and allow employees to remain in control of important decisions.

    For independent research into pest control software, scheduling tools, CRM platforms, and technology comparisons, explore Pest Tech Research.

    Better Technology. Stronger Pest Control.#automation #ai #software #api #coding #development #engineering #inclusive #community
    How AI and Automation Are Changing Pest Control Business Operations

    #ai #community #software #coding #development #engineering
  15. Dev Community @[email protected]

    Navigating a restaurant menu can feel overwhelming—especially when you’re balancing taste preferences, dietary goals, and nutritional concerns. With the explosion of AI food tech in recent years, a new era of “smart menu” experiences is emerging. AI menu analysis isn’t just about digitizing paper menus; it’s fundamentally transforming how diners discover, understand, and choose their meals. From estimating hidden calories to surfacing dishes tailored to your preferences, these innovations are reshaping both dining out and online ordering.

    The Challenge: Decoding Restaurant Nutrition


    Most diners want to make informed choices, but restaurant nutrition information is often buried, incomplete, or absent altogether. Even when calorie counts are available, they rarely account for personal needs—like allergies, macros, or dietary restrictions. Manually scanning for options that fit your criteria can be tedious and error-prone, especially at busy or unfamiliar restaurants.

    This is where AI menu analysis comes in. By leveraging machine learning, natural language processing, and computer vision, AI-powered systems can extract, interpret, and enhance menu data at scale. The result: more transparent, personalized, and actionable restaurant nutrition insights for both diners and operators.

    How AI Menu Analysis Works

    1. Menu Digitization and Parsing


    The first step is converting static menus into machine-readable data. AI models (often using OCR—Optical Character Recognition) can scan printed or photographed menus and extract structured information. Natural language processing (NLP) is then applied to parse dish names, descriptions, and even detect ingredient lists.

    // Example: Simple menu item extraction using regex and NLP concepts
    const menuText = `
    Grilled Salmon Salad - Fresh greens, grilled salmon, avocado, and vinaigrette. 450 kcal
    Classic Burger - Beef patty, cheddar, lettuce, tomato, brioche bun. 800 kcal
    `;

    const dishRegex = /(.*?)\s*-\s*(.*?)\.\s*(\d+)\s*kcal/gi;
    const menuItems = [];
    let match;

    while ((match = dishRegex.exec(menuText)) !== null) {
    menuItems.push({
    name: match[1].trim(),
    description: match[2].trim(),
    calories: parseInt(match[3], 10)
    });
    }

    console.log(menuItems);

    Real-world systems go much further, handling inconsistent formatting, synonyms, and multilingual content.

    2. Nutritional Value Estimation


    Many menus lack detailed nutrition facts. AI can bridge these gaps by analyzing dish descriptions and predicting nutrition profiles. This typically involves:

    • Ingredient recognition: Identifying possible ingredients based on dish names and descriptions.
    • Recipe inference: Estimating likely preparation methods and quantities.
    • Database matching: Mapping extracted ingredients to known nutrient databases (like USDA or Open Food Facts).

    Machine learning models trained on vast recipe and nutrition datasets can predict calories, macros, and even allergen presence with surprising accuracy.

    // Pseudo-code: Predicting calories for a dish using AI
    async function estimateDishCalories(dishDescription: string): Promise<number> {
    // This would call an AI model or API trained on recipe/nutrition data
    const estimated = await callCaloriePredictionModel(dishDescription);
    return estimated.calories;
    }

    3. Personalization and Smart Recommendations


    AI menu analysis unlocks highly personalized experiences:

    • Dietary filtering: Instantly flagging dishes that fit vegan, gluten-free, or keto diets.
    • Allergen detection: Highlighting items that may contain peanuts, shellfish, or other triggers.
    • Preference learning: Recommending dishes based on past orders, ratings, or explicit preferences.
    • Health scoring: Ranking menu items by metrics like calorie density, sodium content, or “healthiness” for the user.

    Some apps leverage collaborative filtering (like Netflix or Spotify) to surface dishes that similar users have enjoyed. Others use reinforcement learning to improve suggestions over time.

    // Example: Filtering menu items for a vegetarian user
    const vegetarianKeywords = ['vegetable', 'cheese', 'tofu', 'salad', 'beans'];
    function isVegetarian(dish: { description: string }) {
    const desc = dish.description.toLowerCase();
    return vegetarianKeywords.some(keyword => desc.includes(keyword));
    }

    const vegetarianOptions = menuItems.filter(isVegetarian);
    console.log(vegetarianOptions);

    4. Enhanced Menu Interfaces


    Modern “smart menu” platforms use AI to power interactive interfaces, both on-premise (via tablets or QR codes) and online. Features include:

    • Dynamic search: Type “high-protein, under 500 calories” and see instant matches.
    • Visualizations: See nutrition breakdowns, allergen alerts, or compare dishes side-by-side.
    • Voice assistants: Ask for “spicy vegan options” and get spoken recommendations.

    This not only improves accessibility for all diners, but also helps restaurants stand out in a crowded market.

    AI Food Tech in Action


    A growing ecosystem of AI food tech products is making these features widely available:

    • Restaurant apps and POS systems: Many now integrate AI-driven nutrition and filtering.
    • Third-party platforms: Apps like Yummly, OpenMenu, and LeanDine offer AI-powered menu analysis, personalized recommendations, and nutrition transparency across thousands of restaurants.
    • Custom deployments: Some restaurant groups build proprietary AI models tailored to their cuisine and customer base.

    On the backend, open-source libraries (such as spaCy for NLP, or TensorFlow for custom ML models) enable developers to integrate AI menu analysis into their own applications.

    Challenges and Considerations


    While the potential is tremendous, deploying AI menu analysis at scale isn’t trivial:

    • Data quality: Menus are notoriously inconsistent—misspellings, colloquial names, and “secret sauce” ingredients can trip up even the best models.
    • Cultural and regional variation: Dishes with the same name can differ wildly in composition.
    • Privacy and consent: Personalization requires collecting user preferences and sometimes health data, raising important privacy questions.
    • Model transparency: Explaining how calorie or allergen predictions are made is essential for trust and regulatory compliance.

    Addressing these challenges requires careful engineering, ongoing model retraining, and clear communication to both restaurants and diners.

    Building a Simple AI-Driven Smart Menu (Example)


    Suppose you want to provide a “smart menu” experience in your own restaurant web app. At a high level, you’d:

    1. Digitize the menu (via OCR, manual entry, or import).
    2. Parse dish descriptions and structure the data.
    3. Augment with nutrition estimates using an AI API or open database.
    4. Add filtering and ranking based on user dietary preferences.
    5. Display results in a user-friendly, interactive UI.

    Here’s a simplified TypeScript-style sketch:

    type MenuItem = {
    name: string;
    description: string;
    calories?: number;
    isVegan?: boolean;
    };

    function filterMenu(
    items: MenuItem[],
    { maxCalories, veganOnly }: { maxCalories?: number; veganOnly?: boolean }
    ): MenuItem[] {
    return items.filter(item => {
    if (maxCalories !== undefined && (item.calories ?? Infinity) > maxCalories) {
    return false;
    }
    if (veganOnly && !item.isVegan) {
    return false;
    }
    return true;
    });
    }

    // Example usage:
    const smartMenu = filterMenu(menuItems, { maxCalories: 500, veganOnly: true });

    You could further extend this with AI-powered search, nutritional scoring, or even integration with fitness tracking apps.

    The Road Ahead


    The fusion of AI menu analysis and restaurant nutrition transparency is just beginning. As machine learning models improve and data becomes richer, expect even more granular, actionable insights—like real-time portion customization, automatic pairing suggestions, or even “health nudges” based on your goals.

    For both diners and restaurants, smart menus powered by AI food tech are making eating out (and ordering in) a more informed, inclusive, and enjoyable experience.

    Key Takeaways


    • AI menu analysis transforms static restaurant menus into dynamic, personalized, and nutrition-aware experiences.
    • Restaurant nutrition information is becoming more transparent and actionable through machine learning and NLP.
    • Smart menu systems enable dietary filtering, allergen detection, and personalized recommendations at scale.
    • A host of AI food tech solutions—from open-source libraries to commercial platforms—make integration possible for developers and restaurants of all sizes.
    • Challenges remain around data quality, privacy, and transparency, but the future of AI-powered dining is bright—and getting smarter with every meal.


    #ai #healthtech #webdev #tutorial #software #coding #development #engineering #inclusive #community
    How AI Is Making Restaurant Menus Easier to Navigate

    #ai #community #software #webdev #coding #development
  16. Emily @[email protected]

    I decided to get serious and return to using #FTM for #genealogy again. So last night I opened the software and tried to sync with Ancestry and was told my tree file was corrupted. And my backups were corrupted. And my Antenna tree in TreeCloud was corrupted. I nuked everything and redownloaded my tree from Ancestry. Thanks Ancestry.
    Tonight I thought I could get back to genealogy but no, TreeCloud is upset because my current tree is not my antenna tree. I tried to replace the old corrupt antenna tree with the current tree but it won’t let me because the Connect program had 3 sticky notes in it that I had made on my iPad. TreeVault believes that means I’m sharing access with someone and their access must be preserved.

    So LiveChat says they will have the TreeVault team manually delete my old corrupt antenna tree and then they will email me to let me know I can upload my new current tree as the new antenna tree for TreeCloud.

    This entire TreeCloud system brought about rather than just letting people sync through OneDrive or iCloud so that they can charge their $25/year or whatever it is and then I don’t even have control over the storage space I am paying for.

    These kinds of things are why I switched to using Ancestry despite their godawful citations because I think I’ve had to phone the Ancestry help desk maybe twice in 20 years but I’m supplying my life info to LiveChat pretty much seasonally. But some point in retirement I want to cut genealogy expenses so having my work in my own computer is key.

    I tried Gramps once and could not get my head around it. RootsMagic is fine except for the slow-drip syncing which drives me crazy.

    Thank you for reading my irritated software rant.

    #ftm #genealogy
  17. Dark Web Informer :verified_paw: @darkwebinformer

    🚨 Critical Okta Access Gateway flaw allows administrators to execute system commands; CVE-2026-115547

    The vulnerability affects the Okta Access Gateway Admin Console and carries a CVSS score of 9.1.
    ⠀
    An authenticated administrator can submit specially formatted configuration values to execute commands within the context of the OAG service account.

    Key details:

    • Network exploitable
    • Low attack complexity
    • Administrative access required
    • No user interaction required
    • Affects OAG versions before 2026.10.2
    ⠀
    Okta has resolved the vulnerability in Access Gateway 2026.10.2. Administrators should manually upgrade affected appliances.

    Source:
    trust.okta.com/security-adviso

  18. Dev Community @[email protected]

    Introduction


    You've been there: you're using an app, and you think, "If only it had feature X." But instead of waiting for the product team, you can build an AI agent that reverse engineers the app's API and implements that feature yourself. This post introduces REA (Reverse Engineering Agent), a pattern for building such agents. We'll walk through a concrete implementation in Python that inspects a web app's network traffic, infers API endpoints, and generates code to replicate missing functionality.

    The Problem


    Modern web apps are complex. Their features are often powered by undocumented internal APIs. When you want to extend or automate them, you're left guessing endpoints, parameters, and authentication. Manually reverse engineering is tedious and error-prone.

    The Solution: REA


    REA is an agent that:

    1. Captures HTTP traffic from a target app (using a proxy like mitmproxy).
    2. Analyzes requests/responses to identify API patterns.
    3. Generates Python code that replicates desired features.
    4. Validates the generated code against the live API.

    The agent operates in a loop with explicit termination conditions: either it successfully generates and validates the code, or it exhausts a maximum number of iterations.

    Implementation


    We'll build a simplified REA using Python, mitmproxy, and OpenAI's API. The agent will reverse engineer a hypothetical "todo" feature from a demo app.

    Prerequisites


    pip install mitmproxy openai requests

    Step 1: Capture Traffic


    We'll use mitmproxy's scripting to log requests to a file. Save this as capture.py:

    from mitmproxy import http
    import json

    class Capture:
    def response(self, flow: http.HTTPFlow):
    if "api" in flow.request.pretty_url:
    entry = {
    "method": flow.request.method,
    "url": flow.request.pretty_url,
    "headers": dict(flow.request.headers),
    "body": flow.request.get_text(),
    "response": flow.response.get_text()
    }
    with open("traffic.jsonl", "a") as f:
    f.write(json.dumps(entry) + "\n")

    addons = [Capture()]

    Run mitmproxy with this script:

    mitmproxy -s capture.py

    Configure your browser to use mitmproxy as a proxy, then use the app to trigger the feature you want to replicate. The traffic will be logged to traffic.jsonl.

    Step 2: Analyze Traffic and Generate Code


    Now, we'll write the REA agent. It reads the captured traffic, asks an LLM to infer the API, and generates Python code. We'll use OpenAI's function calling to structure the output.

    import json
    import openai

    openai.api_key = "YOUR_API_KEY"

    # Load captured traffic
    traffic =
    []with open("traffic.jsonl") as f:
    for line in f:
    traffic.append(json.loads(line))

    # Prepare a summary for the LLM
    summary =
    []for entry in traffic:
    summary.append({
    "method": entry["method"],
    "url": entry["url"],
    "request_body": entry["body"],
    "response_snippet": entry["response"][:200]
    })

    prompt = f"""
    Given these HTTP requests and responses from a web app, infer the API endpoints and generate Python code using the `requests` library to perform the following feature: "Create a new todo item".

    Traffic summary:
    {json.dumps(summary, indent=2)}

    Return a JSON object with keys: `endpoint`, `method`, `headers`, `payload_template`, and `code`. The `code` should be a complete Python function that takes necessary parameters and returns the response.
    """

    response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}],
    temperature=0
    )

    result = json.loads(response.choices[0].message.content)
    print("Generated code:\n", result["code"])

    Step 3: Validate Generated Code


    The agent should test the generated code against the live API. We'll extract the function and run it with sample data.

    import requests

    # Extract the function from generated code (simplified)
    # In production, use a sandboxed environment!
    exec(result["code"], globals()) # SECURITY WARNING: Never exec untrusted code in production.

    # Assuming the function is named `create_todo`
    try:
    response = create_todo("Test todo")
    if response.status_code == 200:
    print("Validation successful!")
    else:
    print("Validation failed:", response.status_code)
    except Exception as e:
    print("Error during validation:", e)

    The Agent Loop


    A full REA agent would iterate: if validation fails, it feeds the error back to the LLM to refine the code. The loop terminates when validation succeeds or after max_iterations (e.g., 5).

    max_iterations = 5
    for i in range(max_iterations):
    # Generate code (as above)
    # Validate
    if validation_success:
    break
    else:
    # Add error to prompt for next iteration
    prompt += f"\nPrevious attempt failed with error: {error}"

    Key Takeaways


    • REA agents can automate reverse engineering of web APIs by combining traffic capture with LLM-powered code generation.
    • Always include explicit termination conditions in agent loops to avoid infinite execution.
    • Security: Never execute generated code without sandboxing. Use containers or restricted environments.
    • This approach is for educational purposes; respect terms of service and privacy laws.

    By building your own REA, you can unlock features that apps don't provide, tailored to your workflow.

    Note: This implementation is inspired by agentic patterns but is not a formal protocol. The term "REA" is used descriptively.#ai #python #webdev #tutorial #software #coding #development #engineering #inclusive #community
    REA: Let Your AI Agent Reverse Engineer the App Features You Wish You Had

    #ai #community #software #webdev #coding #python
  19. Anarchy Inc @[email protected]

    Here we have my collection of portable minidisc players. Three Sony and one Marantz, MZ-E40, MZ-N505, MZ-N4200, and PMD650. None of the recorders record at the moment. But, the MD-N4200 will record via WebMiniDiscPro if it is standing upright. So, I have been manually recording on my Sony Deck. web.minidisc.wiki/ #minidisc #sony

    #sony #minidisc
  20. Dev Community @[email protected]

    Yesterday, I helped troubleshoot a failed GBase Database(GBase 8a) installation in a POC environment. The error was a Python SyntaxError near the beginning of SetSysEnv.py.

    The engineer confirmed that Python 2 was installed. But when we checked the default interpreter, we found the real problem:

    which python
    python -V

    The python command pointed to /usr/bin/python3.

    Python 2 was installed, but the installation script was running under Python 3.

    That small difference can prevent a GBase Database installation script from parsing correctly. Reinstalling the package or changing file permissions won't fix an interpreter mismatch.

    1. Check the Python Version Before Installing


    Some GBase Database(GBase 8a) installation packages use Python 2 scripts. The required runtime depends on the product release and installation package, so verify the official documentation before changing the environment.

    Start with these checks:

    which python
    python -V

    which python2
    python2 -V

    rpm -q python2 python-libs

    On newer systems, including CentOS 8, RHEL 8, and Kylin V10, the default python command may point to Python 3 or may not exist at all.

    Having Python 2 installed does not guarantee that the installer will use it.

    2. Verify Which Interpreter the Installer Actually Uses


    If the supported GBase Database package requires Python 2, check the interpreter entry point expected by that release.

    Also check whether different users resolve python differently:

    su - gbase -c 'command -v python; python -V'

    Replace gbase with the actual database operating system account used in your environment.

    The root user's PATH may differ from the database user's PATH. Shell profiles, custom environment variables, and tools such as Conda can all affect interpreter selection.

    For multi-node deployments, perform the same checks on every node. Correcting the template machine does not guarantee that manually modified or previously cloned nodes have the same configuration.

    3. Configure Python Carefully


    If the official installation instructions require Python 2, install the appropriate runtime and dependencies using the supported method for your OS.

    On systems that provide the alternatives mechanism, a configuration might look like this:

    alternatives --display python

    If your OS and product documentation explicitly permit changing the system-wide python alternative, configure it accordingly. For example:

    alternatives --install /usr/bin/python python /usr/bin/python2 100
    alternatives --set python /usr/bin/python2

    python -V
    type -a python

    Important: Do not apply these commands blindly to every Linux distribution. Changing the system-wide Python interpreter can break OS utilities or other software that expects Python 3. Prefer a product-supported runtime, isolated environment, or documented configuration when available.

    After changing the configuration, open a fresh login shell and verify the result again.

    4. Don't Confuse Interpreter Errors with Other Failures


    The error message often provides the first useful clue.

    • SyntaxError near the start of a script: Check whether the script is running under the required Python version.
    • Missing Python module: Verify the required packages and module search path.
    • External command failure midway through execution: Investigate the command, permissions, environment variables, and dependencies.
    • Different results between users: Compare PATH, shell profiles, and interpreter locations.

    A Python version mismatch is a useful hypothesis, not proof that every installation failure has the same cause.

    5. Use the Documented Installation Entry Point


    Follow the installation procedure for your specific GBase Database release. If the script expects to be invoked through the python entry point, do not assume that calling it directly with python2 is equivalent; the installer may perform additional environment checks.

    For example, if the official instructions specify:

    python gcinstall.py

    use that documented command rather than improvising a different invocation.

    Apply the same principle to SetSysEnv.py: confirm the supported interpreter and invocation method before running it.

    6. Add Python Checks to Your Pre-Install Checklist


    For a multi-node GBase Database deployment, record these details before installation:

    • Hostname and operating system version.
    • Kernel version and CPU architecture.
    • Required Python version.
    • Resolved path of the python command.
    • Python version under the account that runs installation.
    • Relevant package and dependency versions.

    A quick check can save hours of troubleshooting:

    hostname
    cat /etc/os-release
    uname -r
    command -v python
    python -V

    Run it on every node and compare the results before proceeding.

    Final Takeaway


    When GBase Database installation fails with a Python syntax error, check the interpreter before replacing packages or editing scripts.

    The important question is not simply whether Python 2 is installed. It is whether the installer is using the interpreter required by that particular release.

    TIL question: Have you encountered a database installation failure caused by the default Python interpreter pointing to the wrong version?

    Keywords: GBase Database, GBase 8a installation, Python 2 compatibility, Python SyntaxError, CentOS 8, RHEL 8, Kylin V10, database troubleshooting#gbase #database #数据库 #todayilearned #software #coding #development #engineering #inclusive #community
    TIL: Why GBase Database Installation May Require Python 2

    #数据库 #gbase #todayilearned #inclusive #engineering #development
  21. Dev Community @[email protected]

    What I Built
    I built SlothSummarizer, a local, offline, open-source AI CLI tool that reads your messy group chat exports or meeting notes and hands you a strict two-line summary plus a maximum of three action items.
    Who gets to be lazier? Anyone who has ever woken up to 400+ unread messages in a group chat, only to find out the only important thing was "Meeting moved to 3 PM." Instead of scrolling for 15 minutes, you run this tool locally and get the gist in seconds.
    Demo
    Here is an example of the terminal output when feeding it a messy chat log:

    🦥 SlothSummarizer is waking up slowly...

    --- 🌅 Your Lazy Morning Summary ---
    The group discussed moving the Wednesday meeting to 3 PM and agreed on ordering pizza for the office.
    Action items:
    - Confirm the 3 PM meeting room booking.
    - Collect dietary restrictions for the pizza order by Tuesday EOD.
    ------------------------------------

    Code
    The core logic is a simple Python script that calls Ollama's local API. Here's the summarization function:

    import ollama

    def summarize_chat(file_path):
    with open(file_path, 'r', encoding='utf-8') as f:
    chat_text = f.read()[-4000:]

    prompt = f"""You are SlothSummarizer, a lazy but efficient AI assistant.
    Read the following chat log. Provide exactly:
    1. A two-line summary of what happened.
    2. A bulleted list of up to 3 action items (if any).

    Chat log:
    {chat_text}
    """

    response = ollama.chat(model='llama3.2', messages=[
    {'role': 'user', 'content': prompt},
    ])

    print(response['message']['content'])

    How I Built It
    I built this using Python and Ollama, running the llama3.2 open-weight model entirely via local inference.
    The script reads a text file, truncates it to fit safely within the local context window, and passes it to the locally hosted llama3.2 model with a strict system prompt demanding extreme brevity. No cloud APIs, no external dependencies beyond the local Ollama daemon.

    Why Does Open Innovation Matter?


    Open innovation is the only reason this tool is viable for its intended purpose:
    Absolute Privacy: Group chats and personal notes are sensitive. Running an open-weight model locally means my data never leaves my machine or goes to a third-party server.
    Zero Cost & No Rate Limits: Closed APIs charge per token. Summarizing large, messy text files frequently would incur costs or hit rate limits. With open-source local inference, it costs nothing to run, encouraging true "set it and forget it" laziness.
    Offline Reliability: It works on a laptop with no internet connection, perfectly embodying the "Slow and Steady" theme.

    My Agent Session


    While this is a straightforward local script rather than a multi-step agent harness, the development process involved iteratively refining the prompt in Ollama to ensure the model strictly adhered to the "two-line summary + max 3 bullets" rule, resisting the urge to be overly verbose.

    The Lazy Payoff


    I tested this on a real 300-message WhatsApp export from a project group. Reading it manually would have taken ~12 minutes. Running SlothSummarizer took 8 seconds of local inference time and saved me from reading 250+ messages of "lol", "k", and off-topic tangents. I now run it every morning on my overnight chat exports.

    Prize Categories


    Local-first AI / Privacy-focused AI (Open-weight models running locally)#devchallenge #hf26challenge #software #coding #development #engineering #inclusive #community
    🦥 SlothSummarizer: A Local, Offline AI Tool for Lazy Mornings

    #hf26challenge #devchallenge #inclusive #engineering #development #coding
  22. Psychology News Robot @[email protected]

    DATE: October 23, 2026 at 07:00AM
    SOURCE: PSYPOST.ORG

    ** Research quality varies widely from fantastic to small exploratory studies. Please check research methods when conclusions are very important to you. **
    -------------------------------------------------

    TITLE: “AI psychosis” appears rare but real, and first-episode patients may be most vulnerable, study suggests

    URL: psypost.org/ai-psychosis-appea

    A review of electronic health records at a large medical center suggests that conversational artificial intelligence chatbots are associated with worsening psychotic symptoms in a small fraction of mental health patients. These interactions tend to validate preexisting delusions and appear to occur most frequently among patients experiencing their very first episode of psychosis. The findings were published in JAMA Psychiatry.

    Psychosis is a psychiatric condition in which a person loses touch with reality, often experiencing hallucinations or delusions, which are firmly held false beliefs that persist despite contradictory evidence. These false beliefs frequently adapt to reflect the surrounding culture and the latest consumer gadgets. For example, a study covered by PsyPost in 2025 found that more than half of patients experiencing delusions incorporated modern technology, such as smartphones and social media algorithms, into their false beliefs.

    Unlike passive technologies like television or radio, modern artificial intelligence chatbots actively converse with users in real time. Some researchers have used the term “AI psychosis” for cases in which chatbot interactions are linked to emerging or worsening psychotic symptoms. The author of a 2023 commentary argued that chatbot conversations feel so realistic that users can sense a real person on the other end while knowing there isn’t one, and that this tension might fuel delusions in people prone to psychosis.

    Subsequent medical observations began to back up these early warnings. A 2025 study of psychiatric records in Denmark, first released as a preprint and since published in a peer-reviewed journal, identified 38 patients whose mental health appeared to suffer after using chatbots, most commonly through the worsening of their delusions. While early reports and the Danish data established that the phenomenon exists in clinical settings, researchers still lacked systematic data from the United States examining the specific traits of affected patients and the exact roles chatbots play in their illness.

    To address this, Zachary Bergson and senior author Julia M. Sheffield, who leads the Sheffield Lab and is an associate professor of psychiatry and behavioral sciences at Vanderbilt University Medical Center, along with their colleagues, conducted a systematic analysis of patient records at their institution. They aimed to estimate how often AI psychosis appears in a large American hospital system, identify the clinical characteristics of the affected individuals, and categorize how chatbot conversations interact with psychotic symptoms.

    “The study was motivated by the lack of published data on the prevalence and characteristics of AI Psychosis,” Sheffield told PsyPost. “Many theoretical articles had been published, but very few empirical studies existed at the time we started. We wanted to understand simply: 1) at Vanderbilt, how prevalent is AI Psychosis? 2) what generally characterizes AI Psychosis cases in terms of demographics and psychiatric history, compared to other individuals with psychosis who have reference to AI in their medical record but did not develop AI Psychosis.”

    The researchers searched an electronic health record database containing 578,058 medical progress notes from 215,712 unique patients who received behavioral health care between December 1, 2022, and April 15, 2026. They filtered these records for keywords related to artificial intelligence and narrowed the pool to patients who had a documented diagnosis of a psychotic disorder. Two raters manually reviewed the resulting notes to remove irrelevant matches, ultimately identifying 187 medical encounters across 73 unique patients.

    The team divided these 73 patients into three distinct groups based on how they interacted with the technology, with raters agreeing on the group assignment 86.1% of the time. The first group, labeled “neutral interaction,” included 17 patients who used chatbots for everyday tasks unrelated to their mental illness, such as searching for cooking recipes. The second group, “AI-related psychotic content,” consisted of 28 patients who held delusions about artificial intelligence in general, but had no documented history of actually using a chatbot.

    The third group, representing “AI psychosis,” included 28 patients whose medical notes documented chatbot use that appeared to worsen their psychotic symptoms. The researchers also checked each patient’s medical history to see if their hospital visit represented their very first psychotic episode, known clinically as an index episode.

    For the 28 patients in the AI psychosis group, the authors further sorted the interactions into four theoretical categories describing how the software influenced the illness, reaching 83.3% agreement between raters. A “catalyst” interaction meant the chatbot triggered new psychotic symptoms in a previously healthy person. An “amplifier” meant the chatbot worsened existing symptoms by validating distorted ideas. A “coauthor” interaction involved the user and the machine building a harmful narrative together through back-and-forth dialogue, while an “object” interaction meant the chatbot itself became the target of the patient’s delusional beliefs.

    The 28 patients identified with AI psychosis represented 0.013% of all patients receiving mental health care at the medical center during the study period. This group was predominantly male, at 67.9% (though the neutral group was even more heavily male, at 88.2%), and White, at 75.0%, with a median age of 27.5 years. Patients in the AI psychosis group were younger than those who merely held general delusions about artificial intelligence without using a chatbot, who had a median age of 36.5 years.

    The authors note that this rate converges with figures from OpenAI, which has reported that about 0.07% of ChatGPT users active in a given week show possible signs of mental health emergencies related to psychosis or mania, though the two figures measure different populations.

    “This is a relatively small percent, and is in line with what has been reported by the tech companies using in-house data that the public does not have access to,” Sheffield explained. “However, 28 people just within a single medical center is still a lot of patients and families that have been impacted, and if you scale this up to the number of people using generative AI, that is millions of people around the world. In addition, psychosis is a highly distressing and often debilitating experience, that can be difficult to recover from; so if AI is contributing to the experience or severity of psychosis, then it needs to be considered potentially harmful to mental health.”

    When comparing clinical histories, the researchers found no statistically significant differences between the three groups regarding prior psychiatric hospitalizations, past use of psychiatric medications, outpatient treatment history, or past suicide attempts. However, a major difference emerged regarding the stage of the patients’ illness. About 60.7% of the patients in the AI psychosis group were experiencing their first episode of psychosis, compared to just 17.6% in the neutral interaction group and 28.5% in the AI-related content group.

    In addition, patients in the AI psychosis group were more likely to be diagnosed with “unspecified psychosis” (a temporary or broad diagnosis often used when a patient’s exact condition is still being evaluated), at 28.6%, compared to 0% in the neutral group. Among the AI psychosis cases, OpenAI’s ChatGPT was the specific product named in 53.6% of the records. Notably, 85.7% of all AI psychosis interactions were recorded after May 2024, which coincided with the release of the GPT-4o model.

    Looking at the four categories of chatbot interaction, the researchers found that the technology functioned as an “amplifier” in 64.3% of the AI psychosis cases. It served as the “object” of delusions in 21.4% of cases, and acted as a “catalyst” in 10.7% of cases. None of the cases fit the “coauthor” category, and one case could not be classified into any of the four types.

    “Our finding that the majority of AI Psychosis cases were first episode patients confirmed our suspicions, but was still striking to see in the data,” Sheffield said. “In reading the notes from the medical record it was clear that those vulnerable to or in the midst of experiencing psychosis for the first time were turning to AI for answers, understanding or support and were instead having their delusional thought content confirmed or amplified.”

    “AI Psychosis the worsening of psychotic experiences (typically delusional beliefs) in the context of using generative chat-based AI is a real clinical phenomenon that we observe in practice,” she added. “People are coming to behavioral health providers in the real world with these types of experiences.”

    These findings align with a case report covered by PsyPost in late 2025, which detailed an individual patient rather than a retrospective cohort of electronic health records, and similarly found that conversational AI chatbots often amplify and validate psychotic delusions. The results are also consistent with the peer-reviewed version of the Danish records study described earlier, which was covered by PsyPost in early 2026 and documented how chatbot interactions were associated with exacerbated delusions, self-harm or suicidal ideation, and eating disorders among vulnerable psychiatric patients.

    One outside expert said that as large language models (LLMs), the technology that powers conversational chatbots, become part of everyday life, their mental health risks and potential benefits both need study. “This study is one of the first to dive into texts from medical records to find suggestions for associations between use of LLMs and psychosis,” Iris Sommer, a professor and psychiatrist at the University Medical Center Groningen in the Netherlands and president of the Schizophrenia International Research Consortium, who was not involved in the study, told PsyPost. “This study found remarkably few cases of an association between LLM use and psychosis (only 0.013% of service users). With the steep increase in LLM use in recent years, this frequency can be expected to also go up.”

    “While the potential for triggering or worsening psychosis is an important issue to investigate, there is also potential of a broadly available app, that can be used in many languages, free of charge, which may offer some benefits to those struggling with mental health issues who do not have access to any form of regular mental health care,” Sommer added. “Understanding in which circumstances and for which users LLM use can be harmful or helpful is a major challenge that mental health researchers are now facing.”

    The concentration of cases after May 2024 coincides with the release of GPT-4o, a model OpenAI later acknowledged had at times been overly sycophantic, meaning it tended to flatter users and agree with them rather than push back. The authors caution that their design cannot show the model caused these cases, and the timing could also reflect the overall growth in chatbot use and in clinicians’ attention to it. Still, when a person in the early, confusing stages of psychosis shares a distorted belief with an overly agreeable chatbot, the software may validate the belief rather than challenge it.

    At the same time, chatbot technology continues to evolve as developers adjust how their models handle sensitive topics. “The newer versions of commercially available LLMs are less likely to confirm irrational or unlikely beliefs than the initial (2022 and 2023) versions,” Sommer noted. “Newer versions have become trained to recognize signs of psychosis, depression or mania and now recommend seeking professional help (also providing local possibilities to find professional help) when such signs are detected.”

    There are a few things to keep in mind when interpreting these findings. Because the study relied on existing medical notes, the prevalence rate of 0.013% only reflects cases where doctors happened to ask about or document technology use. Clinicians do not routinely screen patients for chatbot habits, meaning many interactions likely went unrecorded, and first-episode patients may also receive more thorough intake interviews that make chatbot use more likely to be noted.

    The study’s observational design also means it cannot establish that chatbots directly cause psychosis in otherwise healthy people. In most cases, the medical notes described chatbots as appearing to amplify symptoms that were already developing, though three cases were classified as chatbot use preceding new symptoms in previously healthy people. Additionally, the data came from a single medical center in Tennessee, and the four-part classification system used to sort the interactions has not yet been formally validated for clinical use.

    “We cannot say from this study if AI use causes psychosis or simply exacerbates it,” Sheffield noted. “This is similar to studies on substance use: for those vulnerable to psychosis, using cannabis or other substances may worsen psychosis symptoms but we frequently cannot say for certain that it caused them. However, the addition of a pervasive, always available, technology that interacts with mental health in a negative way is highly concerning and requires regulation.”

    Sommer was more cautious about the “AI psychosis” label itself. “We should be rather careful with this very term, as causality is very difficult to establish, as the authors of this paper also emphasize,” she said. “LLM use may coincide with psychosis, but if it is the delusional way of thinking that has triggered LLM use or the other way around is rather difficult to disentangle retrospectively. Also, if LLM use worsens psychotic symptoms, or if LLM use increases as a result of more delusional thinking is also difficult to tease out.”

    To better understand how these digital conversations unfold, the authors note that future research should track patients over time and directly analyze their actual chat logs, rather than relying solely on doctors’ summaries. In the meantime, the researchers suggest that mental health professionals consider routinely asking patients about their use of conversational artificial intelligence during psychiatric evaluations.

    “I just attended the first annual AI Psychological Research Coalition (AIPRC) conference, which brought together academia, advocacy and policy to discuss AI regulation,” Sheffield said. “I hope my research can add to this conversation about what types of AI use are harmful for those at risk for psychosis. I also am very interested in understanding how delusional ideas are reinforced by chatbots, in order to reverse-engineer this process, with an eye towards treatment.”

    Sommer agreed that examining the actual transcripts of these digital conversations is a necessary step forward. “An important next step would be to analyze the exact interactions between people with emerging psychotic symptoms and LLMs,” she said. “Such analyses should be undertaken open-minded, with a focus on both potentially harmful and helpful interactions.”

    The study, “Characterizing Artificial Intelligence Psychosis in a Large Medical Setting,” was authored by Zachary Bergson, Sarah G. Vassall, Adam Wright, Allison B. McCoy, Katherine M. Schafer, Margaret C. Achee, and Julia M. Sheffield.

    URL: psypost.org/ai-psychosis-appea

    -------------------------------------------------

    Private, vetted email list for mental health professionals: clinicians-exchange.org

    Unofficial Psychology Today Xitter to toot feed at Psych Today Unofficial Bot @PTUnofficialBot

    -------------------------------------------------

    #psychology #counseling #socialwork #psychotherapy @psychotherapist @psychotherapists @psychology @socialpsych @socialwork @psychiatry #mentalhealth #psychiatry #healthcare #depression #psychotherapist #AI #ArtificialIntelligence #MentalHealth #Psychosis #AIPsychosis #ChatGPT #GenerativeAI #Psychiatry #MentalHealthAwareness #AIResearch

    #psychology #counseling #socialwork #psychotherapy #mentalhealth #psychiatry
  23. ZEN SecDB @[email protected]

    🚨 This time the bug isn’t in your code, it’s in PHP itself.

    PHP2Shell is two CVEs in the PHP runtime (CVE-2026-109618, CVE-2026-109619) that can lead to unauthenticated RCE.

    When something like this lands, the first question is usually: what exactly is affected, and what do I need to patch?

    I’d rather answer that from the terminal than from twelve browser tabs.

    With the ZEN SecDB CLI:

    1️⃣ secdb search php2shell

    finds both CVEs.

    2️⃣ secdb cve CVE-2026-109618

    gives the full record: description, CVSS 4.0 at 9.2, CVSS 3.1 at 9.8, vectors, references and vendor advisories from Debian, Red Hat, SUSE, Ubuntu, Arch, Gentoo, FreeBSD and others.

    That’s useful because you can quickly check whether your distro already ships a fix, instead of going through each security tracker manually.

    If you run PHP, upgrade to 8.5.12, 8.4.27, 8.3.36 or 8.2.35, or use the patched package provided by your distro.

    Configuration mitigations may reduce the risk, but they don’t replace patching.

    And if the server was exposed, it’s probably worth checking whether it was already compromised.

    ZEN SecDB: secdb.nttzen.cloud
    CLI: github.com/giterlizzi/secdb-cli
    CVE-2026-109618: secdb.nttzen.cloud/cve/detail/
    CVE-2026-109619: secdb.nttzen.cloud/cve/detail/

    #PHP2Shell #PHP #RCE #InfoSec #VulnerabilityManagement #CVE #CVE2026109618 #CVE2026109619
    #NTTDATA #ZENSecDB

    #php2shell #php #rce #infosec #vulnerabilitymanagement #cve
  24. Dev Community @[email protected]

    🦥 Nudgify: An AI-Powered Productivity Companion That Does the Remembering So You Can Do the Living | Hacktoberfest: Slow and Steady


    What if your productivity app didn't just wait for you to remember things, but actually helped you stay on top of them?

    We all have those little tasks that seem insignificant until we forget them.

    Reply to that message. Finish that assignment. Remember that deadline. Follow up with a friend. Prepare for tomorrow. Do that one thing you've been postponing for the past three days.

    Individually, these tasks aren't particularly difficult. The problem is remembering all of them, keeping track of when they need to happen, and making sure nothing important slips through the cracks.

    That's where Nudgify comes in.

    For this Hacktoberfest challenge, Slow and Steady, I wanted to explore an idea that feels simple but has a surprisingly meaningful impact: building technology that takes repetitive mental work off our hands.

    Nudgify is an AI-powered reminder and productivity assistant designed to help people manage their responsibilities, remember important tasks, and stay accountable without constantly having to organize everything themselves.

    Because sometimes, the smartest thing technology can do is give us one less thing to worry about.

    🦥 1. The Inspiration: Maybe We Don't Need to Work Harder


    The theme of this week's challenge is inspired by International Sloth Day, and honestly, I think there's something worth learning from sloths.

    They don't rush around unnecessarily. They conserve energy and move at their own pace.

    Meanwhile, we live in a world where everyone seems to be juggling ten different things simultaneously.

    College assignments, project deadlines, internship applications, messages from friends, personal goals, and a never-ending list of things we promise ourselves we'll do later.

    The funny part? Sometimes, we spend so much energy remembering what we need to do that we have less energy left to actually do it.

    Think about a typical student.

    You have an assignment due next week. A friend asks you to remind them about something tomorrow. You need to submit an application, prepare for an upcoming test, and finish a project you've been putting off.

    You might write some of these things down. You might set a few alarms. You might even promise yourself that you'll remember everything.

    And then, inevitably, something gets forgotten.

    The problem isn't necessarily laziness. It's that our brains aren't designed to function as perfect notification systems.

    What if we stopped expecting people to remember everything and started building software that helped them remember what matters?

    That question became the starting point for Nudgify.

    💡 2. What Is Nudgify?


    Nudgify is an AI-powered productivity companion built around a straightforward idea:

    Let software handle the remembering, organizing, and nudging, so people can focus on doing.

    Instead of treating reminders as isolated alarms, Nudgify explores a more helpful approach to everyday productivity.

    The goal is to create an experience where tasks, deadlines, and accountability are easier to manage, whether you're trying to stay organized yourself or helping a friend stay on track.

    Here are the core ideas behind the project.

    ⏰ Smarter reminders


    A reminder should do more than simply exist somewhere in a list.

    It should help you bring your attention back to something at the right moment.

    Nudgify is designed around making important tasks easier to track and revisit, reducing the need to repeatedly check your schedule or mentally calculate how much time remains before a deadline.

    🧠 Less mental clutter


    How many times have you opened your phone to check one thing and ended up scrolling for twenty minutes, only to forget what you originally intended to do?

    A productivity tool should reduce the number of things demanding your attention, not become another source of distraction.

    Nudgify aims to keep important responsibilities visible without requiring users to constantly monitor them.

    🤝 Accountability between friends


    Productivity isn't always a solo activity.

    Sometimes, a little encouragement from someone else makes a difference. Friends can have shared goals, upcoming deadlines, or commitments they want help remembering.

    Nudgify explores how an assistant can make this kind of accountability easier while keeping the experience centered on the people using it.

    The objective isn't to turn friendships into project-management systems. It's to make helping each other a little easier.

    🤖 AI as a practical assistant


    AI is often presented through spectacular demonstrations: generating entire applications, answering complicated questions, or producing impressive pieces of content.

    But I think one of its most valuable applications is much more ordinary.

    It can help make repetitive digital workflows feel less tedious.

    Rather than using AI simply because it's fashionable, Nudgify is an exploration of how AI can support a genuinely useful everyday experience.

    🔓 3. Why Open-Source AI?


    This is the part of the challenge that interests me most.

    The Slow and Steady challenge isn't simply asking us to build an application with AI somewhere in the stack. It specifically encourages us to explore open-weight models, open-source AI frameworks, local inference, and other open technologies that meaningfully power our projects.

    And there's a reason that distinction matters.

    When developers build exclusively around a closed AI service, they can become dependent on a provider's available models, pricing structure, API limits, and infrastructure.

    That can be perfectly reasonable for some projects. Hosted AI services are convenient and can be incredibly capable.

    However, convenience shouldn't be the only option.

    Open-source AI and open-weight models give developers more room to experiment with how AI is deployed, customized, and integrated into an application.

    For a project like Nudgify, that flexibility creates several interesting possibilities.

    🔓 A. Freedom to choose the model


    Different AI models have different strengths.

    One might be better at following structured instructions. Another might be faster for simple tasks. A smaller model might be sufficient for extracting dates or classifying reminders, while a more capable model might be useful for complicated requests.

    An open approach allows developers to evaluate alternatives instead of designing the entire product around one provider.

    For example, a future version of Nudgify could use a lightweight model for straightforward reminder processing and reserve more capable models for tasks that genuinely require them.

    The model becomes a component that can be evaluated and replaced, rather than a permanent limitation on the product's design.

    🔐 B. Privacy should be part of the architecture


    Think about the information a personal productivity assistant might handle.

    It could contain assignment deadlines, daily routines, personal commitments, private notes, and reminders involving other people.

    This information may not look especially sensitive when considered individually, but together it can reveal a great deal about someone's life.

    That raises an important question:

    Does every AI-powered task really need to send personal information to an external server?

    Not necessarily.

    For tasks that can be handled by a sufficiently capable local model, local inference could allow processing to happen on the user's own device.

    That would provide an opportunity to reduce external data transfers and give users more control over their information.

    Local processing isn't automatically private in every respect, and the rest of the application still needs appropriate data-handling practices. However, reducing unnecessary transmission is a meaningful architectural advantage.

    💻 C. AI that doesn't always depend on the internet


    Imagine opening your productivity assistant while travelling, sitting somewhere with unreliable connectivity, or working away from your usual setup.

    If an appropriate model runs locally, certain AI features could remain available without an internet connection.

    That would make the application less dependent on network availability for those particular tasks.

    Of course, a fully offline experience requires more than downloading a model. Data storage, authentication, synchronization, and any external notification services must also be designed to support offline use.

    Still, local inference makes offline AI a realistic design possibility rather than something that necessarily requires a remote API.

    💸 D. Lower barriers to experimentation


    Experimenting with AI can become expensive when every iteration depends on a metered API.

    You might want to test different prompts, compare models, change how an assistant behaves, or run repeated evaluations.

    Open-weight models can make it possible to conduct some of this experimentation without paying a separate hosted-inference fee for every request.

    That doesn't mean running AI is always free. Hardware, electricity, hosting, and infrastructure can all have costs, and some model licenses impose additional conditions.

    But having the option to run models on hardware you already own can make experimentation more accessible.

    For students and independent developers, that matters.

    You shouldn't need a large budget just to explore an idea.

    🛠️ E. The freedom to understand and change things


    Perhaps the most important benefit is the freedom to learn by doing.

    When a model is open-weight and its license permits the intended use, developers can inspect its available artifacts, run inference, evaluate its behavior, and sometimes fine-tune it.

    Open-source frameworks can also make it easier to understand and modify the surrounding application logic.

    Instead of treating the AI component as a mysterious service, you can investigate how it works, compare alternatives, and build a system that suits your requirements.

    For a student developer, that freedom is valuable in itself.

    Open innovation isn't just about using something that is free. It's about having more control over what you can build with it.

    🧩 4. Why This Approach Fits Nudgify


    A reminder assistant might seem like a small application, but it presents some interesting design questions.

    Which tasks actually require AI?

    Which can be handled with ordinary code?

    When should the application notify the user? What information needs to be stored? What happens if a notification is delayed? How can the assistant remain helpful without becoming annoying?

    These questions are just as important as the model itself.

    For example, consider a reminder scheduled for tomorrow at 10 AM.

    There is no reason to ask an AI model to continuously calculate the time until that reminder. A conventional scheduling system can handle that reliably.

    AI might be useful when a user describes a task in natural language, needs help interpreting an ambiguous request, or wants to turn an unstructured instruction into a structured task.

    A well-designed application can combine both approaches.

    TaskAppropriate approachStore a reminderDatabase or structured storageCalculate time until a deadlineOrdinary application logicInterpret a natural-language taskAI, when usefulSchedule a notificationScheduling infrastructureGenerate a short task summaryAI, when usefulDeliver notifications while a tab is closedBrowser push infrastructure and a push-capable backend


    This separation is important because AI shouldn't be used for everything simply because it is available.

    Reliable application logic should handle predictable operations, while AI should be reserved for tasks where flexible language understanding or generation adds genuine value.

    That also creates a natural opportunity to use a smaller open-weight model for suitable AI operations without making every part of the application dependent on inference.

    🏗️ 5. Building the Application: The Technology Behind Nudgify


    Nudgify uses a modern web-development stack designed to support an interactive frontend, application logic, and AI integration.

    The current project stack includes the following technologies:

    Frontend


    React 19

    React provides the component-based foundation for the user interface. It allows the application to be organized into reusable components rather than a collection of disconnected screens.

    Vite 8

    Vite provides the development and build tooling for the frontend, helping keep the development workflow fast and straightforward.

    TypeScript 7

    TypeScript adds static typing to JavaScript, making it easier to define data structures and catch certain mistakes during development.

    For an application that handles tasks, deadlines, and user interactions, clear data structures help keep the codebase maintainable.

    Tailwind CSS v4

    Tailwind CSS provides utility-based styling that makes it possible to develop and refine the interface without maintaining a huge collection of unrelated CSS rules.

    The objective is to create an experience that feels like a practical product, rather than a technical demo assembled around an AI API.

    Backend


    Node.js and Express 4

    The backend provides the foundation for handling application requests and server-side workflows.

    Keeping backend responsibilities separate from the frontend also provides room to evolve the application as its functionality grows.

    AI integration


    Google Gen AI SDK

    The project includes the Google Gen AI SDK for AI integration.

    This is an important distinction for the open-source AI challenge: a hosted AI SDK does not, by itself, make an application open-source-AI-powered.

    To make open AI central to Nudgify, the model layer needs to incorporate a suitable open-weight model or an appropriate open-source AI component as a meaningful part of the actual application.

    That could involve evaluating a locally hosted model, adding a compatible inference backend, or building a model adapter that makes switching between supported models straightforward.

    The goal is not to add an open model just to satisfy a checklist. It is to use the model where it provides real value.

    Data storage


    Browser localStorage

    The project uses browser localStorage for supported client-side data.

    This can be useful for lightweight persistence, but it is important to understand its limitations: browser storage is tied to a particular browser and origin, isn't automatically synchronized between devices, and shouldn't be treated as a secure database for sensitive information.

    A more complete multi-user application may require server-side persistence, appropriate access controls, and a clear strategy for data synchronization.

    Each part of the stack has a purpose, and understanding those boundaries is part of building a product that can grow beyond its initial prototype.

    🔔 6. Notifications: A Reminder Is Only Useful If It Reaches You


    There's another practical challenge with reminder applications.

    Imagine creating a reminder, closing the browser tab, and assuming the application will notify you when the time comes.

    If the application only checks for reminders while its page is open, that assumption may not hold.

    This is why notification delivery deserves its own design.

    A browser notification displayed by an open page is not the same as a push notification delivered when the page is closed.

    A more robust implementation can involve:

    • A service worker to receive push events where supported.
    • The Web Push API to deliver notifications to subscribed browsers.
    • A backend capable of scheduling and sending push messages.
    • Persistent storage for reminders and their delivery status.
    • Appropriate permission handling and user consent.

    For deadline-based reminders, the application also needs to distinguish between when a task is due and when a notification should be sent.

    For example, if a task is due at 10 AM on Friday, a user might want a reminder on Thursday morning, another shortly before the deadline, or both.

    These are scheduling decisions that ordinary backend logic can handle without repeatedly asking an AI model.

    A future version of Nudgify could combine dependable notification infrastructure with AI-assisted task interpretation, producing a system that is both helpful and predictable.

    That distinction matters: a clever assistant is not much use if its reminders never arrive.

    🦥 7. What Does “Slow and Steady” Mean in Practice?


    For me, this theme is about more than helping someone procrastinate comfortably.

    It's about being intentional with the work we ask people to do.

    There are many repetitive tasks that don't require our full attention, but still consume time because we haven't automated them.

    We repeatedly check deadlines. We reread task lists. We try to remember conversations. We manually organize information that could be structured automatically.

    Some of these activities are necessary. Others can be simplified.

    Nudgify explores the second category.

    Imagine a student who has several assignments due in the same week.

    Instead of repeatedly opening different lists and calculating which assignment needs attention first, a well-designed assistant could present the next relevant task and help the student stay aware of approaching deadlines.

    Imagine a friend who regularly forgets to follow up on a commitment.

    An assistant could help make the commitment visible at an appropriate time, reducing the need for another person to remember to remind them.

    Imagine a user who has a long list of tasks but feels overwhelmed by it.

    A carefully designed interface could make the next action easier to identify instead of presenting an intimidating wall of unfinished work.

    None of these ideas requires an AI model to do everything.

    They require a thoughtful combination of automation, reliable scheduling, useful interface design, and AI where it genuinely improves the experience.

    The aim is to save attention, not simply to produce more notifications.

    🌱 8. What I Learned From Thinking About Open AI


    One thing this project highlights is that building with AI involves much more than choosing a model.

    You need to think about how the model fits into the application, what data it receives, where inference takes place, and what happens when it isn't available.

    You also need to understand the difference between an open-source framework, an open-weight model, and a hosted service.

    These terms are related, but they aren't interchangeable.

    An open-source framework can provide an inspectable and modifiable implementation without making the model it calls open-weight.

    An open-weight model makes its trained weights available under a particular license, but that doesn't automatically mean every part of its training data, development process, or surrounding infrastructure is open.

    And a hosted AI service can be useful without giving you control over the model's deployment.

    Recognizing these differences helps developers make more informed architectural decisions.

    For Nudgify, the interesting direction is to keep the application flexible enough to experiment with open-weight inference while maintaining a clear separation between AI-assisted features and ordinary application functionality.

    That flexibility would make it easier to evaluate different models based on practical criteria such as response time, resource requirements, instruction-following ability, privacy considerations, and licensing.

    It also creates opportunities to learn more about inference, model deployment, and the trade-offs involved in bringing AI from a prototype into a usable product.

    For me, that's one of the strongest arguments for open innovation: it turns AI from something you merely consume into something you can actively experiment with and learn from.

    🚀 9. Where I'd Like to Take Nudgify Next


    There are several directions I'd like to explore as the project develops.

    1. A genuinely interchangeable model layer


    I want the application architecture to make it easier to compare models and switch between compatible inference backends without rewriting the entire application.

    That would make experimentation more practical and reduce unnecessary dependence on a single provider.

    2. Local inference where it makes sense


    Running a model locally could make selected AI features available without sending every request to an external service.

    The exact experience would depend on the model, the user's hardware, and the application's other dependencies.

    A lightweight model may be sufficient for some tasks, while more demanding operations may still benefit from hosted inference.

    3. Better deadline-aware workflows


    Reminders should be connected to meaningful task information.

    The application could help users distinguish between upcoming deadlines, overdue tasks, and commitments that need attention soon.

    The goal is to make information actionable rather than simply adding more items to a list.

    4. More reliable notification delivery


    A reminder system should be designed around dependable delivery, including appropriate handling of permissions, scheduling, and delivery failures.

    That infrastructure would allow the assistant to be useful even when the user isn't actively looking at the application, where browser and platform capabilities permit.

    5. Privacy-conscious data handling


    As the application grows, I want to pay more attention to what information is stored, what information needs to leave the device, and how user data is protected.

    Local inference could help with some of these decisions, but privacy needs to be considered throughout the application rather than delegated to the model alone.

    6. A less distracting productivity experience


    More features don't automatically make a productivity tool better.

    I'd rather explore ways to make Nudgify feel useful and unobtrusive than turn it into another application that demands constant attention.

    After all, the whole idea is to reduce the amount of effort users spend managing their responsibilities.

    💚 10. Why This Project Matters to Me


    As a student and developer, I find it exciting that we can build increasingly sophisticated applications without needing to own an enormous infrastructure stack.

    Modern web frameworks make it easier to build interactive applications, and the growing open AI ecosystem creates more opportunities to experiment with models and inference systems.

    But what interests me most is the possibility of using those tools to solve ordinary problems.

    Not every useful project needs to revolutionize an industry.

    Sometimes, making it easier for someone to remember a deadline is worthwhile. Sometimes, reducing the number of repetitive steps in a workflow is enough. Sometimes, the best feature is one that quietly works in the background and lets the user get on with their day.

    Nudgify is my exploration of that idea.

    The project brings together productivity, automation, and AI with the intention of making everyday responsibilities a little easier to manage.

    And the Slow and Steady challenge provides a particularly fitting reminder that good technology doesn't always have to encourage people to move faster.

    It can also help them waste less energy on things that don't deserve so much of their attention.

    🏁 Final Thoughts


    The future of AI shouldn't be limited to massive models, expensive APIs, or applications that send every task to a remote service.

    There is room for smaller models, local inference, open-source tools, and carefully designed systems that solve specific problems well.

    Open innovation gives developers more opportunities to experiment with these approaches, understand their limitations, and decide which trade-offs make sense for their users.

    For Nudgify, that means exploring how an AI assistant can help people remember what matters, automate repetitive work, and spend less time managing their own productivity.

    The bigger lesson is that automation isn't necessarily about doing more.

    Sometimes, it's about making room for less stress, fewer unnecessary steps, and more time for the things we actually care about.

    Build something useful. Automate the boring parts. Keep the technology open where it matters. And remember: you don't have to rush to make progress. 🦥

    🔗 Project Links


    • GitHub Repository: [Add your Nudgify repository link]
    • Live Demo: [Add your deployed application link]
    • Demo Video: [Add your demonstration link, if available]

    I'd love to hear from other developers: What's one repetitive task you'd automate with an open-weight AI model, and would you run it locally or in the cloud?

    Let's build tools that save people time, energy, and attention.

    Hacktoberfest #SlowAndSteady #OpenSourceAI #OpenInnovation #ArtificialIntelligence #AI #WebDevelopment #React #TypeScript #BuildInPublic #DeveloperCommunity

    #devchallenge #hf26challenge #software #coding #development #engineering #inclusive #community
    Nudgify

    #ai #community #software #coding #development #artificialintelligence
  25. Dev Community @[email protected]

    Understanding cosine similarity, Euclidean distance, and how machines find relevant text and images.

    1. Why do we need semantic search?


    Imagine you're building a search feature for your application.

    A user searches:

    How do I make my application faster?


    Your database contains these articles:

    1. How to optimize database queries
    2. Improving API performance with caching
    3. A beginner's guide to JavaScript arrays
    4. How to bake a chocolate cake

    Which articles should appear first?

    Traditional keyword search looks for matching words. Since the first two articles don't contain the exact phrase "make my application faster," a basic keyword search might rank them poorly.

    Semantic search takes a different approach: it searches for meaning, not just matching words.

    It can recognize that "make my application faster," "optimize database queries," and "improve API performance" may describe related ideas.

    To understand how semantic search works, we need three concepts:

    • Embeddings: Representing text or images as numbers.
    • Vectors: Working with those numbers mathematically.
    • Similarity and distance: Comparing vectors to rank relevant results.

    Let's build these concepts from scratch using simple mathematics and JavaScript.

    2. What is a vector?


    A vector is an ordered list of numbers.

    For example:

    const vector = [3, 4];

    We can imagine this vector as a point on a two-dimensional graph:

    • 3 represents the horizontal coordinate.
    • 4 represents the vertical coordinate.

    The point is therefore located at (3, 4).

    A vector can have two dimensions, three dimensions, or thousands of dimensions.

    For learning purposes, we'll use two-dimensional vectors because they're easy to visualize and calculate by hand.

    Important: These examples use illustrative numbers. Real embedding dimensions generally don't have simple, individually interpretable meanings.

    3. What is an embedding?


    An embedding is a numerical representation of content generated by a machine-learning model.

    Imagine an embedding model converts three sentences into vectors:

    SentenceIllustrative embedding"Make my app faster"[0.9, 0.1]"Improve application performance"[0.8, 0.2]"Chocolate cake recipe"[0.1, 0.9]


    The first two vectors point in similar directions. The third points in a different direction.

    This gives us a way to compare content mathematically.

    The embedding model learns useful representations during training. Our search system uses those representations to find and rank related content.

    A simplified semantic-search pipeline looks like this:

    User query
    |
    v
    Embedding model
    |
    v
    Query vector
    |
    v
    Compare with document vectors
    |
    v
    Rank relevant documents

    Now let's explore the mathematics behind those comparisons.

    4. Vector magnitude: how long is a vector?


    Before comparing vectors, let's understand their length, also called their magnitude or L2 norm.

    Suppose we have:

    a = [3, 4]

    The magnitude is calculated using the Pythagorean theorem.

    Step 1: Square both coordinates.

    ‖a‖₂ = √(3² + 4²)

    Step 2: Simplify the squares.

    ‖a‖₂ = √(9 + 16)

    Step 3: Add the values and calculate the square root.

    ‖a‖₂ = √25 = 5

    Therefore, the magnitude of vector [3, 4] is 5.

    In simple terms, the magnitude tells us how far the point is from the origin, (0, 0).

    Implementing magnitude in JavaScript


    function magnitude(vector) {
    const sumOfSquares = vector.reduce(
    (sum, value) => sum + value * value,
    0
    );

    return Math.sqrt(sumOfSquares);
    }

    console.log(magnitude([3, 4])); // 5

    Here's what the code does:

    1. Squares every value.
    2. Adds the squared values together.
    3. Takes the square root of the sum.

    We'll reuse this function when calculating cosine similarity.

    5. Euclidean distance: how far apart are two vectors?


    Magnitude measures the distance from the origin. Euclidean distance measures the distance between two points.

    Suppose we have two points.

    Point A

    a = [1, 2]

    Point B

    b = [4, 6]

    How far apart are they?

    First, calculate the difference between their coordinates:

    • Horizontal difference: 4 − 1 = 3
    • Vertical difference: 6 − 2 = 4

    Using the Pythagorean theorem:

    d = √(3² + 4²)

    d = √(9 + 16)

    d = √25 = 5

    The Euclidean distance is 5 units.

    The general L2 distance formula


    For two vectors with the same number of dimensions:

    dL2(a, b) = √[Σᵢ₌₁ⁿ (aᵢ − bᵢ)²]

    You don't need to memorize the notation immediately. Remember the process:

    1. Subtract corresponding coordinates.
    2. Square each difference.
    3. Add the squared differences.
    4. Take the square root.


    Implementing L2 distance in JavaScript


    function l2Distance(a, b) {
    if (a.length !== b.length) {
    throw new Error("Vectors must have equal dimensions");
    }

    const sumOfSquares = a.reduce((sum, value, i) => {
    const difference = value - b[i];
    return sum + difference * difference;
    }, 0);

    return Math.sqrt(sumOfSquares);
    }

    const a = [1, 2];
    const b = [4, 6];

    console.log(l2Distance(a, b)); // 5

    How does this help with semantic search?


    Imagine our query has already been converted into a vector:

    const query = [2, 3];

    We also have two document embeddings:

    const documentA = [4, 4];
    const documentB = [2, 5];

    Let's calculate the distance from the query to each document.

    Document A

    Distance = √((2 − 4)² + (3 − 4)²)

    Distance = √(4 + 1)

    Distance ≈ 2.236

    Document B

    Distance = √((2 − 2)² + (3 − 5)²)

    Distance = √(0 + 4)

    Distance = 2

    Document B is closer to the query because 2 is smaller than 2.236.

    When ranking by L2 distance, a smaller distance means the vectors are closer together.

    However, Euclidean distance isn't the only way to compare vectors. Another popular metric is cosine similarity.

    6. Dot product: multiplying corresponding values


    The dot product is an operation used in vector mathematics. It also plays an important role in calculating cosine similarity.

    Suppose we have two vectors:

    a = [2, 3]

    b = [4, 5]

    Multiply their corresponding values and add the results:

    a · b = (2 × 4) + (3 × 5)

    a · b = 8 + 15 = 23

    The dot product is 23.

    Implementing dot product in JavaScript


    function dotProduct(a, b) {
    if (a.length !== b.length) {
    throw new Error("Vectors must have equal dimensions");
    }

    return a.reduce(
    (sum, value, i) => sum + value * b[i],
    0
    );
    }

    console.log(dotProduct([2, 3], [4, 5])); // 23

    The dot product combines information from corresponding dimensions. When divided by the magnitudes of both vectors, it gives us the cosine of the angle between them.

    That is the foundation of cosine similarity.

    7. Cosine similarity: are the vectors pointing in the same direction?


    Euclidean distance asks:

    How far apart are two points?

    Cosine similarity asks:

    How closely do two vectors point in the same direction?

    Its formula is:

    cosineSimilarity(a, b) = (a · b) / (‖a‖₂ × ‖b‖₂)

    Let's work through an example.

    Suppose:

    a = [1, 2]

    b = [2, 4]

    Notice that vector B is twice vector A. Both point in exactly the same direction.

    Step 1: Calculate the dot product


    a · b = (1 × 2) + (2 × 4) = 10

    Step 2: Calculate both magnitudes


    For vector A:

    ‖a‖₂ = √(1² + 2²) = √5

    For vector B:

    ‖b‖₂ = √(2² + 4²) = √20

    Step 3: Calculate cosine similarity


    cosineSimilarity = 10 / (√5 × √20)

    Since √5 × √20 = 10:

    cosineSimilarity = 10 / 10 = 1

    The cosine similarity is 1, meaning the vectors point in exactly the same direction.

    Interpreting cosine similarity

    ScoreGeometric interpretation1Same direction0.8Strong positive directional alignment0Perpendicular directions-1Opposite directions


    These are geometric interpretations, not universal thresholds for semantic relevance. Whether a score indicates similar meaning depends on the embedding model and the data.

    Implementing cosine similarity in JavaScript


    function magnitude(vector) {
    return Math.sqrt(
    vector.reduce((sum, value) => sum + value * value, 0)
    );
    }

    function dotProduct(a, b) {
    if (a.length !== b.length) {
    throw new Error("Vectors must have equal dimensions");
    }

    return a.reduce(
    (sum, value, i) => sum + value * b[i],
    0
    );
    }

    function cosineSimilarity(a, b) {
    const magnitudeA = magnitude(a);
    const magnitudeB = magnitude(b);

    if (magnitudeA === 0 || magnitudeB === 0) {
    throw new Error(
    "Cosine similarity is undefined for zero vectors"
    );
    }

    return dotProduct(a, b) / (magnitudeA * magnitudeB);
    }

    console.log(cosineSimilarity([1, 2], [2, 4])); // 1
    console.log(cosineSimilarity([1, 0], [0, 1])); // 0
    console.log(cosineSimilarity([1, 0], [-1, 0])); // -1

    Cosine similarity is useful because multiplying a nonzero vector by a positive number doesn't change its direction. Consequently, cosine similarity is unaffected by positive scaling of either vector.

    This can be helpful when comparing embeddings whose lengths differ.

    8. Cosine distance: turning similarity into distance


    Sometimes we want a distance metric where lower values indicate a closer match.

    A common definition is:

    cosineDistance = 1 − cosineSimilarity

    Suppose Document A has a cosine similarity score of 0.9.

    Distance A = 1 − 0.9 = 0.1

    Document B has a cosine similarity score of 0.6.

    Distance B = 1 − 0.6 = 0.4

    Document A is the closer match under this metric because its cosine distance is smaller.

    Implementing cosine distance


    function cosineDistance(a, b) {
    return 1 - cosineSimilarity(a, b);
    }

    console.log(cosineDistance([1, 2], [2, 4])); // 0
    console.log(cosineDistance([1, 0], [0, 1])); // 1

    Remember the distinction:

    • Cosine similarity: Higher is better for directional alignment.
    • Cosine distance: Lower is better.
    • L2 distance: Lower means the points are closer.

    Implementations and vector databases may define or report metrics differently, so check the documentation for the system you're using.

    9. L2 distance vs. cosine similarity


    Let's compare two vectors:

    a = [1, 1]

    b = [10, 10]

    These vectors point in exactly the same direction, but their magnitudes differ.

    Their cosine similarity is:

    cosineSimilarity(a, b) = 1

    Their cosine distance is:

    cosineDistance = 1 − 1 = 0

    Now calculate their Euclidean distance:

    dL2 = √((1 − 10)² + (1 − 10)²)

    dL2 = √(81 + 81)

    dL2 = √162 ≈ 12.728

    The vectors have perfect directional alignment, yet their Euclidean distance is greater than 12.

    This illustrates the key difference:

    PropertyL2 distanceCosine similarityMeasuresDistance between coordinatesAlignment of directionsAffected by vector magnitude?YesNot by positive scalingBetter scoreSmallerLargerUseful whenCoordinate distance mattersDirectional alignment matters


    Neither metric is always better. The right choice depends on how the embedding model was trained and how its vectors should be compared.

    10. Build a simple semantic-ranking example


    Now let's combine our functions to build a small vector-ranking demonstration in JavaScript.

    Imagine an embedding model has already converted a search query and three documents into two-dimensional vectors.

    const query = [0.8, 0.6];

    const documents = [
    {
    title: "API performance optimization",
    embedding: [0.9, 0.4]
    },
    {
    title: "Database query optimization",
    embedding: [0.7, 0.7]
    },
    {
    title: "Chocolate cake recipe",
    embedding: [-0.5, 0.8]
    }
    ];

    These vectors are invented for demonstration. In a real application, an embedding model would generate them.

    Let's rank the documents by cosine similarity.

    function magnitude(vector) {
    return Math.sqrt(
    vector.reduce((sum, value) => sum + value * value, 0)
    );
    }

    function cosineSimilarity(a, b) {
    if (a.length !== b.length) {
    throw new Error("Vectors must have equal dimensions");
    }

    const dot = a.reduce(
    (sum, value, i) => sum + value * b[i],
    0
    );

    const normA = magnitude(a);
    const normB = magnitude(b);

    if (normA === 0 || normB === 0) {
    throw new Error("Zero vectors are not supported");
    }

    return dot / (normA * normB);
    }

    const rankedDocuments = documents
    .map(document => ({
    title: document.title,
    score: cosineSimilarity(query, document.embedding)
    }))
    .sort((a, b) => b.score - a.score);

    console.log(rankedDocuments);

    The results are approximately:

    [
    {
    title: "Database query optimization",
    score: 0.990
    },
    {
    title: "API performance optimization",
    score: 0.975
    },
    {
    title: "Chocolate cake recipe",
    score: 0.085
    }
    ]

    We sort the results in descending order because higher cosine similarity means stronger directional alignment.

    Notice something important: our JavaScript code doesn't understand language. It only compares vectors.

    The embedding model is responsible for learning useful representations of language. The ranking code uses those representations to order the results.

    Our example demonstrates the mechanics of vector search, not a complete semantic search system.

    11. Where do real embeddings come from?


    So far, we've manually supplied vectors such as [0.8, 0.6].

    Real applications use an embedding model to generate vectors from text or images.

    A typical workflow looks like this:

    1. Choose an embedding model.
    2. Convert each document into a vector.
    3. Store the vectors alongside document IDs and content.
    4. Convert the user's query into a vector using a compatible model.
    5. Find the nearest document vectors.
    6. Return the corresponding documents in ranked order.

    A JavaScript application might call an embedding API like this:

    // Illustrative pseudocode.
    // Replace this with your embedding provider's SDK.

    const queryEmbedding = await embeddingModel.embed(
    "How do I make my application faster?"
    );

    const documentEmbedding = await embeddingModel.embed(
    "Improve API performance with caching."
    );

    const score = cosineSimilarity(
    queryEmbedding,
    documentEmbedding
    );

    console.log(score);

    The exact API depends on your embedding provider. The key requirement is that both vectors must come from compatible embedding representations.

    For thousands or millions of documents, calculating every distance in application code can become expensive. A vector database or search engine can index embeddings and retrieve nearby candidates more efficiently.

    12. Does the same mathematics work for image search?


    Yes. The comparison mathematics is the same, but the process that generates the vectors differs.

    Imagine you're building an image-search application. A user enters:

    A dog playing on a beach.


    A compatible text-image model converts the query into an embedding. It also converts the available images into embeddings in a shared vector space.

    The application compares the query vector against the image vectors and ranks the images by similarity.

    The process looks like this:

    Text query
    |
    v
    Text encoder
    |
    v
    Query embedding
    |
    v
    Compare against image embeddings
    |
    v
    Rank matching images

    This works directly only when the model is designed to produce comparable text and image embeddings.

    Why not simply compare raw pixels?

    Two photographs of the same dog might have different lighting, camera angles, cropping, or backgrounds. Raw pixel differences may be large even when the images depict similar content.

    Learned image embeddings can capture useful visual patterns that raw pixel distance misses.

    However, the model can still make mistakes. A high similarity score is a ranking signal, not proof that an image contains every detail in the query.

    13. Why normalized vectors matter


    Some embedding models produce vectors with a magnitude of 1. These are called L2-normalized vectors.

    For unit-normalized vectors, Euclidean distance and cosine similarity are mathematically related:

    L2 distance² = 2 × (1 − cosine similarity)

    Equivalently:

    L2 distance = √[2 × (1 − cosine similarity)]

    This means that ranking the same unit-normalized vectors by L2 distance or cosine similarity produces the same ordering:

    • Higher cosine similarity means lower L2 distance.
    • Lower cosine similarity means higher L2 distance.

    This relationship can be useful when choosing a metric for a vector index.

    Don't assume every embedding model automatically normalizes its output. Check the model documentation before relying on this property.

    14. What would I use in a real JavaScript application?


    For a practical semantic-search feature, I'd separate the system into four responsibilities.

    1. Embedding model

    Converts text or images into vectors that represent useful features of the content.

    2. Vector database

    Stores the vectors and retrieves nearby candidates efficiently.

    3. Similarity metric

    Determines how the system compares vectors, using cosine similarity, Euclidean distance, or another supported metric.

    4. Application code

    Handles queries, metadata, filtering, ranking, and displaying results to users.

    Start with the metric recommended by your embedding model, then test it against real queries and expected results.

    For example, if you're building documentation search, create a test set of queries such as "make API faster" and identify which articles should appear first. Measure whether those articles show up in the top five results.

    That gives you a practical way to evaluate your search quality rather than choosing a metric based only on intuition.

    You may also want hybrid search, which combines vector similarity with keyword search. This can be especially useful when users search for exact identifiers, error messages, version numbers, or technical terms that must match precisely.

    Conclusion


    Semantic search becomes much easier to understand when we break it into smaller mathematical concepts.

    A vector is an ordered list of numbers. An embedding model converts text or images into vectors. Euclidean distance measures how far apart two vectors are, while cosine similarity measures how closely their directions align. Cosine distance converts similarity into a distance-style score.

    With a few JavaScript functions, we can implement these calculations and build a simple vector-ranking demonstration.

    The most important distinction is this:

    Vector mathematics gives us a way to compare representations. The embedding model learns representations that can capture useful relationships in meaning.

    Both parts matter when building a useful semantic-search system.#ai #machinelearning #search #software #coding #development #engineering #inclusive #community
    How Machines Find Meaning: The Math Behind Semantic Search

    #ai #community #software #coding #development #machinelearning
  26. Dev Community @[email protected]

    Introduction


    Deploying an application to Kubernetes is relatively straightforward when everything works as expected. The real challenge begins when Kubernetes reports that the deployment is running, but the application behaves differently from what the operations team expects.

    In enterprise environments, a successful deployment involves more than updating a container image. Applications often depend on external databases, configuration services, network connectivity, persistent storage, and other components that must work together.

    During my work with enterprise applications deployed on AWS Elastic Kubernetes Service (EKS), I have encountered situations where a pod was running but the application had not initialized, database migrations failed without affecting the reported health status, and new workloads could not be scheduled despite otherwise valid deployment configurations.

    These experiences reinforced an important engineering principle:

    Infrastructure health, application readiness, and business functionality are three different things.

    In this article, I will discuss several practical deployment scenarios, the investigation approaches used, and the architectural lessons they offer.

    The examples are based on real deployment troubleshooting experiences, with infrastructure identifiers and implementation details generalized for confidentiality.

    1. When a Running Pod Is Not a Ready Application


    One particularly interesting deployment incident involved a Java application that started successfully at the container level but failed to complete its internal initialization.

    The new application pod reached the Running state, yet remained 0/1 Ready.

    There was no continuous restart loop. The Java process was still active, and several internal health checks were passing.

    However, the application never became ready to receive traffic.

    Investigation


    The investigation started with basic Kubernetes commands:

    # Check pod status
    kubectl get pods -n <namespace>

    # Inspect pod details and events
    kubectl describe pod <pod-name> -n <namespace>

    # Inspect application logs
    kubectl logs <pod-name> -n <namespace>

    # Inspect deployment rollout status
    kubectl rollout status deployment/<deployment-name> -n <namespace>

    The application logs contained an initialization error similar to:

    java.lang.IllegalStateException: Channel not active

    The error occurred during an internal communication lifecycle callback.

    Further investigation showed that the application's database connectivity, memory, and other basic checks were reporting healthy results.

    However, the application-server readiness check remained unsuccessful.

    The important observation was that the Java process had not terminated.

    This ruled out a conventional application crash and shifted the investigation toward the startup lifecycle.

    Understanding the failure


    The evidence suggested a startup-ordering problem.

    An internal lifecycle operation attempted to use a communication channel before it became active.

    This was consistent with a race condition during application startup, although the available logs did not establish every aspect of the underlying concurrency behavior.

    Because the JVM remained alive, Kubernetes did not report a CrashLoopBackOff.

    The container was running, but the application had not completed initialization.

    This distinction matters because a container's running state only indicates that its process is executing. It does not automatically prove that all required application components are operational.

    Recovery


    A controlled rollout restart initiated a fresh startup attempt:

    kubectl rollout restart deployment/<deployment-name> \
    -n <namespace>

    On the next attempt, the communication component initialized successfully and the pod reached 1/1 Ready.

    The previous application instance remained healthy during the unsuccessful rollout, so the active service was not interrupted.

    However, an important distinction remained.

    Restarting the application resolved the immediate operational problem, but it did not establish that the suspected startup race had been permanently fixed.

    Architectural lesson


    Application readiness must represent the service's ability to perform its intended function, not merely the presence of a running Java process.

    For enterprise applications with multiple initialization stages, startup dependencies should be explicit.

    When one component depends on another, the application should wait for a reliable initialization signal rather than assuming that the dependent service is ready.

    Where appropriate, Kubernetes startup probes can protect applications that require longer initialization periods, while readiness probes determine whether they should receive traffic.

    A restart may recover from a transient initialization problem, but repeated restarts should not become a substitute for correcting the underlying startup sequence.

    2. When Health Checks Pass but Database Migration Fails


    Another incident revealed a less obvious limitation of application health checks.

    During deployment, database changes were managed through Liquibase. These changes included configuration schema updates and business data migrations.

    In some deployments, the application instances started successfully and reported a healthy status even though one of the database migration operations had failed.

    The problem


    The migration process encountered errors such as:

    Validation Failed:
    Checksum mismatch

    In other cases, the error was related to existing database records:

    ERROR: duplicate key value violates unique constraint

    For example, a migration attempted to insert a configuration record that already existed in the target environment.

    Liquibase stopped processing at the failing changeset, leaving subsequent database updates unapplied.

    However, the application could still establish a database connection and start.

    From Kubernetes' perspective, the application appeared healthy.

    From a release-management perspective, the deployment was incomplete.

    Why this matters


    A database connectivity health check generally answers one question:

    Can the application establish a connection to the database?

    It does not necessarily establish whether:

    • All required migrations have completed.
    • The database schema matches the deployed application version.
    • Required configuration records exist.
    • Data transformations completed successfully.
    • Business-level operations can execute correctly.

    In one deployment scenario, the application image was updated while the business schema remained at the previous version because a migration failed.

    The application was technically running, but the application version and database migration state were no longer aligned.

    This discrepancy was not visible from the application's ordinary health response.

    Investigation


    A reliable investigation should examine both Kubernetes and the database migration process.

    # Inspect available migration jobs
    kubectl get jobs -n <namespace>

    # Inspect the migration job
    kubectl describe job <migration-job-name> \
    -n <namespace>

    # Review migration job logs
    kubectl logs job/<migration-job-name> \
    -n <namespace>

    # Review a specific init container
    kubectl logs <pod-name> \
    -c <init-container-name> \
    -n <namespace>

    Where Liquibase is used, the database changelog tables can provide additional evidence about which changesets were executed.

    A read-only query against a suitably qualified changelog table can help inspect migration history:

    SELECT
    id,
    author,
    filename,
    dateexecuted,
    orderexecuted,
    exectype
    FROM databasechangelog
    ORDER BY orderexecuted DESC;

    The exact table location depends on how Liquibase schemas are configured.

    These checks should be compared against the migration version and changesets expected for the deployed application release.

    Simply finding a database connection or a running pod is insufficient.

    Architectural lesson


    Database migration success should be a separate release validation requirement.

    A reliable deployment process should establish that:

    1. The correct migration scripts were included in the release.
    2. The required changesets completed successfully.
    3. The resulting database state matches the application's expectations.
    4. No required business configuration was omitted.
    5. Representative functional operations succeed after deployment.

    Where possible, migration workflows should be explicitly coordinated with application startup and release promotion.

    Database changes must also be designed with repeatability and idempotency in mind, particularly when different environments may already contain configuration records introduced through earlier operational activities.

    A successful readiness response is not proof that database migration completed successfully.

    3. Resource Constraints During Kubernetes Rollouts


    Another deployment issue occurred when new application pods could not be scheduled because the Kubernetes cluster lacked sufficient resources.

    The affected pod remained in the Pending state.

    Unlike the previous startup failure, the application process had never started.

    Investigation


    The investigation began by checking the pod's scheduling events:

    kubectl get pods -n <namespace>

    kubectl describe pod <pod-name> \
    -n <namespace>

    The events showed messages similar to:

    FailedScheduling:
    Insufficient cpu
    Insufficient memory

    The environment used a small cluster where existing workloads were already consuming most of the available node capacity.

    During the rollout, Kubernetes needed to accommodate both existing and replacement workloads.

    The additional resource demand exceeded the cluster's scheduling capacity.

    Why rolling deployments require spare capacity


    Rolling deployments are intended to introduce new application instances while existing instances continue serving traffic.

    However, that behavior depends on the available resources and the deployment strategy.

    Consider a simplified environment with two existing application workloads.

    During an upgrade, Kubernetes may need capacity for one or more additional pods before terminating older instances.

    If the nodes are already close to their allocatable resource limits, new pods may remain unscheduled.

    The problem can become more visible when blue and green application versions are deployed simultaneously.

    Even if each deployment works individually, the combined resource requirements may exceed the available cluster capacity.

    Additional diagnostics


    Resource investigations may include:

    # Review available nodes
    kubectl get nodes

    # Inspect node capacity and allocated resources
    kubectl describe node <node-name>

    # Inspect resource requests and limits
    kubectl describe pod <pod-name> \
    -n <namespace>

    # View node resource usage if Metrics Server is available
    kubectl top nodes

    # View pod resource usage
    kubectl top pods -n <namespace>

    An important distinction is that the Kubernetes scheduler evaluates resource requests and scheduling constraints, not simply the current CPU or memory utilization shown by monitoring tools.

    Therefore, an apparently idle node may still be unable to schedule a pod if its allocatable resources are already reserved by existing workload requests.

    Recovery considerations


    In non-production environments, temporarily reducing unused application replicas may free enough capacity for a new deployment.

    However, this is an operational workaround rather than a long-term architectural solution.

    More sustainable approaches include reviewing resource requests, planning node capacity, configuring suitable autoscaling, and defining an appropriate rollout strategy.

    Architectural lesson


    Cluster sizing should account for deployment-time resource requirements, not only steady-state application consumption.

    Before implementing a rolling or blue-green deployment strategy, architects should understand:

    • How many old and new pods may coexist.
    • How resource requests affect scheduling.
    • Whether cluster capacity supports temporary workload overlap.
    • Whether autoscaling can provide additional resources.
    • How deployment behavior changes when scheduling is delayed.

    A deployment strategy that works under normal conditions may fail during an upgrade if spare capacity has not been planned.

    4. The Hidden Risk of Configuration Changes


    Containerized applications are often described as immutable deployments.

    While the container image may be immutable, the configuration surrounding the application is not.

    Configuration may originate from Kubernetes ConfigMaps, Secrets, external secret-management systems, application databases, or custom configuration platforms.

    In one deployment scenario, rebuilding application configuration data removed values that the application required.

    The application image itself was not necessarily faulty.

    The problem originated from missing environment-specific configuration.

    Understanding the configuration problem


    Some enterprise applications store configuration records in database schemas rather than exclusively using Kubernetes ConfigMaps or Secrets.

    When deployment procedures rebuild those schemas, configuration that was created or modified manually may be lost unless it is explicitly preserved or recreated.

    This creates an important distinction between deploying new application binaries and rebuilding application configuration.

    A database schema operation can have consequences beyond the code version being deployed.

    Practical example


    Consider an application that depends on:

    • Database connection configuration.
    • External API endpoints.
    • Authentication credentials.
    • Encryption or key-management references.
    • Environment-specific application settings.

    If a configuration rebuild removes one of these values, the application may fail during startup or encounter functional failures after becoming ready.

    The resulting problem can appear to be an application defect even when the real cause is missing configuration.

    Architectural lesson


    Configuration ownership and persistence should be clearly defined.

    A deployment process should identify:

    1. Which configuration is maintained through source-controlled definitions.
    2. Which values are retrieved from external secret-management systems.
    3. Which configuration must survive application upgrades.
    4. Which values are environment-specific.
    5. How required settings are validated before the application becomes available.

    Sensitive values should not depend on manual re-entry after normal deployments.

    Where possible, configuration should be reproducible, securely managed, and validated through automated release processes.

    An immutable container image does not guarantee an immutable or reproducible application environment.

    5. Why Cancelling a Deployment Does Not Guarantee Rollback


    A more complex deployment incident involved an interrupted Helm upgrade.

    The upgrade had already submitted operations to the Kubernetes API server when the client-side process was interrupted.

    Although the operator stopped the command, some server-side operations continued.

    A database operation completed, while the remainder of the deployment did not finish as expected.

    This created a difference between the intended deployment state and the actual state of the environment.

    Understanding the problem


    Helm manages Kubernetes resources through the Kubernetes API.

    When an upgrade starts, resources such as Deployments and Jobs may already have been created or updated.

    Interrupting the Helm command does not automatically reverse every operation already accepted by the Kubernetes API server.

    For example, a migration Job may continue executing after the command that initiated the deployment has been interrupted.

    If that Job modifies an external database, those changes may persist independently of the Helm release state.

    Investigation


    Before attempting another deployment, the actual cluster state must be understood.

    Useful checks include:

    # Check Helm release history
    helm history <release-name> \
    -n <namespace>

    # Inspect the current Helm release
    helm status <release-name> \
    -n <namespace>

    # Check Kubernetes Jobs
    kubectl get jobs -n <namespace>

    # Check pods created by the deployment
    kubectl get pods -n <namespace>

    # Inspect a particular Job
    kubectl describe job <job-name> \
    -n <namespace>

    # Inspect Job execution logs
    kubectl logs job/<job-name> \
    -n <namespace>

    These checks help determine whether deployment-related operations are still active, completed, or failed.

    However, Kubernetes resource status alone may not reveal the full database state.

    Migration logs and database changelog records should also be examined before retrying the release.

    Rollback considerations


    A Helm rollback primarily restores the release's Kubernetes resource configuration to a previous revision.

    It does not automatically reverse all database modifications or external side effects caused by the deployment.

    For this reason, destructive database operations require particular care.

    A cancelled deployment followed by an immediate retry can be dangerous if the first attempt has already partially modified the database.

    Architectural lesson


    Deployment recovery should begin with understanding the actual state, not simply repeating the previous command.

    For complex enterprise applications, recovery procedures should distinguish between:

    • Kubernetes resource changes.
    • Application configuration updates.
    • Database schema modifications.
    • Data migration operations.
    • External integrations or side effects.

    A deployment rollback is not necessarily a business-system rollback.

    6. A Practical Deployment Validation Checklist


    These experiences changed how I think about deployment verification.

    Rather than relying exclusively on a successful Helm command or the readiness status of Kubernetes pods, I prefer to evaluate deployments through several independent validation layers.

    Infrastructure validation


    Verify that the expected pods are scheduled, storage resources are available, networking dependencies are accessible, and workloads have sufficient resources.

    kubectl get pods -n <namespace>

    kubectl get deployments -n <namespace>

    kubectl get pvc -n <namespace>

    kubectl get events -n <namespace> \
    --sort-by=.lastTimestamp

    Application validation


    Confirm that the application has completed initialization and that critical readiness components are operational.

    A running container does not automatically indicate that the application is ready to handle business requests.

    Database validation


    Check that the required migration operations completed successfully.

    Verify the database migration state independently from the application's database connectivity health check.

    Where appropriate, inspect Liquibase changelog history and confirm that the expected release changesets were applied.

    Release validation


    Confirm that the running container image corresponds to the intended release.

    Review the Helm release status and ensure that no unexpected migration or coordination Jobs remain active.

    helm status <release-name> -n <namespace>

    kubectl rollout status deployment/<deployment-name> \
    -n <namespace>

    kubectl get jobs -n <namespace>

    Functional validation


    Exercise representative application operations after deployment.

    For example, enterprise application validation may include authentication, transaction inquiries, API communication, or other critical workflows appropriate to the system.

    Infrastructure health checks should complement functional testing rather than replace it.

    Recovery validation


    Confirm that there is a documented and tested recovery approach if the new release fails.

    This may include preserving the previous application version, restoring configuration, or executing a controlled rollback.

    Database operations that cannot be automatically reversed should be explicitly documented.

    The objective is to ensure that deployment failures can be understood and recovered from without unnecessary additional changes.

    7. Key Lessons from Real-World Kubernetes Deployments


    Across these incidents, several engineering lessons consistently emerge.

    1. Running does not mean ready.

    A container can remain active even when important application initialization steps have failed.

    2. Readiness does not guarantee business correctness.

    A service may pass health checks while database migrations or required configuration updates remain incomplete.

    3. Rolling deployments require additional capacity.

    Resource planning must consider temporary overlap between existing and replacement workloads.

    4. Configuration requires the same discipline as application code.

    Environment-specific settings, credentials, and configuration records should be reproducible and safely managed.

    5. Deployment interruption does not guarantee rollback.

    Kubernetes Jobs, database migrations, and external side effects may continue after the client-side deployment process stops.

    6. Immediate recovery and permanent resolution are different activities.

    Restarting a pod or retrying a deployment may restore service, but unresolved architectural defects can recur.

    7. Deployment success should be validated at multiple levels.

    Infrastructure, application readiness, database state, release consistency, and functional correctness require separate checks.

    Conclusion


    Kubernetes provides powerful capabilities for orchestrating and managing applications, but it cannot automatically determine whether every aspect of an enterprise system is correct.

    The incidents discussed here demonstrate how application startup ordering, database migration state, resource constraints, configuration management, and interrupted deployment operations can affect an otherwise routine release.

    One of the most useful lessons I have learned from working with enterprise applications on Kubernetes is that a green health indicator is evidence of a particular check passing, not proof that the entire system is functioning correctly.

    Reliable deployments require carefully designed readiness signals, explicit migration verification, adequate rollout capacity, controlled configuration management, and meaningful functional validation.

    The objective is not merely to make deployments succeed.

    It is to make their outcomes predictable, observable, and recoverable.

    About the Author

    Naveed Akram is a Solutions Architect at Diebold Nixdorf with nearly 16 years of professional experience in software engineering, enterprise architecture, digital banking, and cloud technologies. His technical interests include distributed systems, Kubernetes, AWS, enterprise integration, and AI-assisted software engineering.#kubernetes #aws #architecture #devops #software #coding #development #engineering #inclusive #community
    Lessons from Deploying Mission-Critical Applications on Kubernetes: Reliability, Configuration, and Troubleshooting

    #devops #community #software #coding #architecture #development
  27. Dev Community @[email protected]

    Stop sharing your credentials with agents — per-agent identity is here, and here's the order to fix things in.

    Disclosure: some links in the original are affiliate links, and we may earn a commission if you buy through them — at no extra cost to you. It doesn't change our analysis, and the security advice below is the same advice we'd give with no links at all.

    You gave an agent a job. To do it, the agent needed to log in somewhere — a dashboard, a cloud console, a bank, a SaaS tool. So you did what almost every developer has done this year: you handed it your password, or a key that works just like one. It is probably still sitting in a prompt, a script, or a .env file you meant to clean up later. That is the quiet security debt of the agent era. Your agents are logging in as you, everywhere — and the institutions on the other end have started to notice.

    How we put this together


    We based this piece on vendor launch materials from 1Password and IDENTOS, reporting by Axios on bank responses to agentic activity, and 1Password's Developer Pulse survey of developers. Where a claim comes from a vendor — launch features, plan inclusion, partner lists, survey results — we label it as a vendor claim or cite the source by name. We have not hands-on tested 1Password for Agents or IDENTOS PolicyArc; this is researched analysis, not a product review.

    Verdict


    Stop sharing your own credentials with agents, starting now. Give each agent its own identity, scoped to one task, for a limited time, with a log you can read and a revoke button that works. Per-agent identity is becoming the default — 1Password for Agents and IDENTOS PolicyArc, both launched this week, are early, concrete versions of it. Fix in this order: inventory what your agents can reach, kill shared passwords, then add scoping, expiry, and audit.

    Why banks are suddenly interested in your agents


    Start with the bank's point of view, because it explains everything else.

    According to Axios reporting, US banks are detecting unverified agentic activity on customer accounts. Chase has warned customers not to share their credentials with third-party agents. Read that warning carefully. The bank is not making a philosophical point about AI. It is telling you that when an automated agent signs in with your username and password, the bank cannot verify who — or what — is actually on the other end.

    Mechanically, the bank is right. A legitimate agent using your password and a criminal using your stolen password produce nearly identical signals: correct credentials, an unfamiliar device or location, odd hours, rapid navigation, no human typing pattern. Fraud systems were built to flag exactly that shape of activity. Your agent does not look like innovation to a risk engine. It looks like account takeover that happens to be polite about it.

    That distinction matters for you even if you never automate a bank login. The same pattern is now playing out across cloud consoles, payment dashboards, ad accounts, and production SaaS tools. When something goes wrong — a bad transaction, a deleted resource, a leaked export — the audit log will say you did it. Because as far as the system is concerned, you did. You gave the agent your identity, so every action it takes inherits your name, your permissions, and your liability.

    And developers are doing this at scale, under real pressure to keep doing it. In 1Password's Developer Pulse survey, 65% of developers said they are expected or encouraged to use AI agents. Only 33% said they have a secure way to let agents sign in. That gap — between "you must use agents" and "here is a safe way to give them access" — is where passwords end up in prompts. It is not carelessness, mostly. It is a missing piece of infrastructure. This week, two companies shipped attempts to fill it.

    The five ways agents sign in today, compared


    There are really only five patterns in use right now. They are not equally good, and we are not going to pretend they are. Here they are, worst to best, with the two launches from this week placed where they belong.

    1. Your shared password — the worst option, and still the most common


    How it works: You give the agent your actual username and password. It stores them in a prompt, a script, a config file, or its own memory, and signs in exactly as you would.

    Strength: It works with everything, immediately, with zero setup. That is the entire list of strengths.

    Weakness: Everything else. The credential has your full permissions — no scoping, no expiry, no way to tell agent actions from your actions in a log. If the prompt leaks, the password leaks. If the agent is compromised, you are compromised. Rotating the password breaks every agent using it, so nobody rotates it. If you are doing this today, you are not alone — but you should treat it as an incident waiting for a date, not a workflow.

    2. Long-lived API keys — better than a password, worse than you think


    How it works: Instead of your password, the agent carries an API key — often created under your account, often with broad permissions, often valid until someone remembers to delete it.

    Strength: At least it is separate from your human login, and most platforms let you revoke a key without changing your password. For machine-to-machine calls to a single API, this is a reasonable baseline.

    Weakness: "Long-lived" is the problem. Keys get copied into repos, CI logs, screenshots, and chat transcripts. They rarely expire, rarely get scoped tightly, and rarely have a human in the loop when they are used. A leaked long-lived key with broad scope is a password with better branding.

    3. Scoped, short-lived tokens — the right shape


    How it works: The agent gets an OAuth-style token limited to specific permissions, for a specific service, for a short window — minutes or hours, not months. When the window closes, the token dies and a new one must be issued.

    Strength: This is the pattern security teams actually want. Least privilege by default, automatic expiry, and a much smaller blast radius if a token leaks. A stolen token that expires in an hour and can only read one project is a bad day. A stolen password is a bad quarter.

    Weakness: Support is uneven. Plenty of tools your agents need still do not offer fine-grained, short-lived tokens, and wiring up issuance and refresh for every agent and every service is real engineering work. The pattern is right; the ecosystem is still catching up.

    4. Per-agent keys with human approval — 1Password for Agents


    How it works: Each agent gets its own identity instead of borrowing yours. 1Password for Agents, launched October 22, 2026, is the clearest consumer-and-developer example so far. As 1Password describes it — a vendor claim, based on its launch materials — each AI agent signs in with its own unique digital key, you approve every sign-in attempt on your own device, and the actual password never reaches the agent. 1Password lists the feature as included in its Individual and Family plans via 1Password.com.

    1Password names its launch partners as rolling out, including Meta's Muse and Grok Bot, with Claude Duet, ChatGPT Work/dots, and Townie listed as coming soon. It also says integrations are being built by Browserbase, Browser Use, Perplexity, and Ramp. Treat that partner list as a vendor roadmap claim until each integration is live and documented — but note the shape of it: browser agents and finance tooling are exactly where credential-sharing risk is highest.

    Strength: The password never reaches the agent, every sign-in needs your approval on your device, and each agent is distinguishable from you and from every other agent. Revoking one agent does not mean changing your password everywhere.

    Weakness: Human approval does not scale forever. Approving every sign-in works for high-value logins; it will chafe for agents that authenticate constantly in the background. And you are trusting one vendor's vault and approval flow with the keys to a lot of doors — convenient, and a concentration risk you should choose with your eyes open.

    5. Policy and audit engines — IDENTOS PolicyArc


    How it works: Instead of managing credentials agent by agent, you define policy in one place: who and what can access which resources, for which tasks, for how long — and you get an audit trail across all of it. IDENTOS PolicyArc, which reached general availability on October 23, 2026, is positioned exactly there. As IDENTOS describes it — a vendor claim from its launch materials — PolicyArc is one place to define, enforce, and audit access policy for people and agents, with task-specific, time-limited access grants.

    Strength: This is the enterprise-grade answer to the real question, which is not "how does this one agent log in?" but "what is every agent in this organization allowed to reach, and can we prove it later?" Central policy, time limits, and audit in one system is what compliance and security teams will ask for.

    Weakness: Weight. A policy engine is infrastructure to evaluate, buy, integrate, and operate. For a solo developer or a three-person team, it can be more machine than the problem needs today. It also only governs the systems you connect to it — an agent with your password typed into a prompt is outside the policy no matter how good the engine is.

    Our ranking, plainly: shared passwords are last, and it is not close. Long-lived keys are a distant fourth. Scoped, short-lived tokens are the baseline every developer should aim for today. Per-agent keys with human approval rank first for individual developers and small teams right now, because they fix the worst failure — password exposure — without a platform rebuild. Policy and audit engines rank first for organizations managing many agents across many people, where the audit trail is the point. Pick based on your scale, but do not pick option one.

    What to do this week


    You do not need to buy anything to start. You need an inventory and the willingness to delete some credentials. Work through this in order — and if you want a structured pass, run our Agent Access Readiness checklist on Pick a Tools alongside it, then read the broader background in our AI Agent Identity hub.

    • Inventory every agent and what it can reach. List every agent, assistant, script, and automation that signs in to anything on your behalf. For each one: what service, what credential, what permissions, who else has that credential. You cannot fix what you have not listed. Most developers find at least one agent they forgot was still running.
    • Kill shared credentials first. Anywhere an agent uses your personal password, stop — this week, not this quarter. Rotate that password, and do not hand the new one to the agent. If the agent breaks, that breakage is information: it tells you the workflow had no safe sign-in path, which is the thing to fix.
    • Scope to least privilege. For every remaining key or token, cut permissions to what the task actually needs. Read-only where read-only works. One project, not the whole account. If a platform only offers an all-or-nothing key, note it as a risk and shorten its life.
    • Make grants time-limited. Prefer short-lived tokens where they exist. Where they do not, put a calendar date on every long-lived key and rotate on schedule. Task-specific, time-limited grants — the model PolicyArc describes — are the target even if you implement them manually for now.
    • Keep audit logs you actually read. A log nobody opens is decoration. Once a week, scan sign-ins and agent actions for the services that matter: anything you do not recognize gets investigated the same day. Separate agent identities make this possible; shared passwords make it pointless.
    • Make revocation one click, and test it. For each agent, know exactly how you would cut its access in under five minutes — and actually test the revoke path once, before you need it during an incident. If revoking one agent means changing your own password and logging yourself out of everything, you still have a shared-credential problem.

    When the inventory is done, score yourself honestly with the Agent Access Readiness tool and fix the lowest-scoring area first. The goal for this week is not perfection. It is making sure no agent anywhere is signing in with your personal password.

    The honest limits


    Some restraint is warranted, because this category is three days old in its current shape and the marketing is running ahead of the standards.

    The standards are unsettled. There is no single, widely adopted protocol for agent identity yet. What 1Password ships, what IDENTOS ships, and what the browser-agent platforms build may converge — or may leave you migrating between incompatible approaches in a year. Early adoption buys you safety now at the price of some rework later. For the password-sharing problem, that trade is still worth it. For a full platform commitment, go in knowing it.

    Platform lock-in is a real risk. If one vault holds every agent key and one vendor's approval flow gates every sign-in, leaving that vendor becomes a project, not a settings change. That may be an acceptable trade — password managers already hold that position in most of our lives — but count it as a cost, not a footnote.

    Small teams may not need an enterprise policy engine yet. If you are two developers with four agents, a written inventory, scoped tokens, and a calendar reminder to rotate keys will carry you further than a policy platform you have not finished integrating. Buy the layer that matches the number of agents and people you actually have. PolicyArc-class tooling earns its keep when "who approved this agent's access, and when does it expire?" becomes a question you cannot answer from memory.

    And this is a developer story first, a consumer story later. The Developer Pulse numbers describe developers because developers are the ones wiring agents into real systems today. Consumers handing agents their banking passwords are the next wave of the same problem — which is precisely why the Chase warning matters. The tooling will follow the developers down-market. Your job is to not still be sharing passwords when it arrives.

    The bottom line has not changed since the first paragraph. Agents are useful, agents are not going away, and agents need to sign in to things. All of that can be true while "sign in as me, with my password, forever" is a bad answer. This week gave developers the first mainstream alternatives. Use them — starting with the unglamorous work of listing what your agents can reach, and taking your own password back.

    FAQ


    How do AI agents log in today?
    Most agents today log in with credentials borrowed from a person: a shared password, a long-lived API key pasted into a prompt or .env file, or a broad OAuth token. Newer approaches give each agent its own scoped, short-lived credential, or a per-agent key that requires human approval for every sign-in.

    What is 1Password for Agents?
    1Password for Agents, launched October 22, 2026, is a feature where each AI agent signs in with its own unique digital key instead of your password. You approve every sign-in attempt on your own device, and the actual password never reaches the agent. 1Password lists it as included in its Individual and Family plans.

    Why are banks flagging agent activity?
    According to Axios reporting, US banks are detecting unverified agentic activity on accounts. An agent signing in with your password from an unfamiliar location or automation pattern is mechanically indistinguishable from account takeover fraud, which is why Chase has warned customers not to share credentials with third-party agents.

    What is an agent identity?
    An agent identity is a distinct, revocable identity for a single AI agent — separate from any human user — with its own credential, limited permissions, and an audit trail. It lets you grant task-specific, time-limited access and revoke that one agent without changing your own password or breaking other tools.

    What should a developer do first?
    Inventory every agent you run and what it can reach, then kill shared credentials first. Move agents to scoped, short-lived, or per-agent credentials, add time limits and audit logs, and make sure you can revoke any single agent in one click.

    What is IDENTOS PolicyArc?
    IDENTOS PolicyArc, which reached general availability on October 23, 2026, is described by IDENTOS as a single place to define, enforce, and audit access policy for people and agents, including task-specific, time-limited access grants.

    Originally published on Pick a Tools.#security #ai #programming #devops #software #coding #development #engineering #inclusive #community
    Your AI Agents Are Logging In With Your Password. Banks Have Noticed.

    #devops #ai #security #community #programming #software
  28. Dev Community @[email protected]

    “They didn't burn the libraries — they trained them with AI”

    Craft and Authorship Devalued

    Adobe was built for productivity, it's not doing the work for you like an OpenAI subscription generating both text and imagery through prompts. Commercial AI services are now devaluing craft, labor, skill, and almost anything made or written by hand. Authorship is sinking.

    People now find it acceptable to generate work with a prompt, with random art materials they didn't make, and without any ability to make their art. This profoundly changes the meaning of making art and disrupts all digital art. It all becomes Dadaism. Not all artists decide to go Dada. It’s obscuring the meaning of all new digital art with a diminished sense of guessing what is real and what isn’t.

    Whose work is it? Permission, provenance and the library

    Would David Lynch be okay with people generating an avatar of himself on behalf of his estate? I don’t think so, I even asked Claude themselves and they said no. There must be permission first, it’s not an all you can eat buffet of borrowing others.

    Hayao Miyazaki's view on people generating his art style strongly opposed generative AI as an “insult to life itself”, it’s about preserving his work and the Ghibli team's legacy, it's his choice if he allows a technology company to reappropriate his work and not anyone else's.

    Can someone please tell Sam Altman to ask for permission or wait a hundred years til it's in the public domain? If major publishers change their mind because authors and artists are being taken advantage of, could it impact OpenAI or Anthropic? Maybe until they find the right lawyer.

    We’re entering a provenance, attribution, and appropriation nightmare of who said what and who made what. When a library gets trained into a model, you lose the chain of who wrote it. References without understanding, art school 101 becoming the whole internet.

    The business model is trained on everyone's work for free, no fee up front, then sells it back as the means of production. This is precisely how it’s replacing the skills and jobs of production. This is essentially the ethos of the WGA fight at civilizational scale.
    Naomi Klein has described it as a “humanity surplus” where archives, libraries, authorship as a whole are told humans aren’t needed, it implies people are working for free. The libraries are all already dust, with the alarming peer to peer pressure in staying quiet about it as an elite tribe of twitter accounts convince people how to do business, with AI prebuilt into everything, while risking a possible impact of a third of our economy if slop falls into flop…

    Labor and the creative industries

    The writers obviously, and the artists, even the designers, engineers, programmers and coders, nearly all authors involved, all craftsmen involved—the proletariat, are becoming displaced, labor obscured into an industrial wildcard.

    One of many industries impacted with the brunt of the damage is the illustrator. People who draw fell into a depression after generating art became commercialised with prompts generating illustrations in a desired art style. Everyone who can draw, paint, render, and everything in between clashing in competition.

    Artists were displaced almost immediately after competing with the whole Internet and prompts through AIs generating images. On the other hand, it’s created a renewed appreciation for people who create by hand simultaneously.

    It's a bit daunting if you're in art school right now. The entire entertainment industry (including films, music, and video games) are all in a digital-only transition in the middle of a writer's strike across several industries while the OpenAI business model asphyxiates them. Here are the warnings too familiar to us all, the industry is truly shape-shifting and everyone is outpaced by it.

    This might be a bit sardonic but a portion of the entire movement of music has funneled its value into an AI defense weapon, with Spotify’s Daniel Ek’s AI defense company ‘Helsing’, a portion of human expression through music ended up being a weapon for war. The music industry is dying because people are struggling with selling it. Spotify does not give you a music file of what you listen to, right? Spotify unfortunately is led by two or three people hoarding labels and publisher's profit, so all of the world's human expression through music is published through a handful of people who lead streaming platforms and channel it into weapons manufacturing while the entertainment industry is in the middle of a precise market collapse tied to creatives.

    Don’t get me started with Suno. We’re talking about people with no ability creating a zombie apocalypse music festival here. It’s fostering the laziest and robotic sounding art I’ve ever heard. Spotify actually recently removed 75 million AI pieces, finally, all AI stuff should be separated unless the artist builds their own AI tools sourcing their own materials/assets. If the artist picks out the materials and builds automated tools, that’s acceptable. If it’s generating random materials then it’s all absurdist thievery.

    In theory, every time an AI chatting service references sources of any material, its source should then receive at least a penny, it’s a digital revolution both suppressed and maybe “empowered” by commercial products.

    Media dissonance

    The other day I witnessed an artist’s photography work flagged as “likely to be AI” when it was pretty clear it was manual photography by a human, she threw a fit and I also couldn’t believe it.

    People think AI chatting services can only generate images and text and it’s no big deal, if that isn’t already taunting all of independent journalism, the creative industry and the art world along with it, imagine being an author worrying about what’s AI or not and who wrote what. It’s really taking out a sense of curiosity and discovery in the joy of absorbing any art form. If Claude already knows who won the World Cup, that's a major problem.

    Here’s one of the worst realisations, proceed with caution: commercially generated art distracted NASA’s photography team on Instagram, there’s a moment where you observe an interstellar nebula and you’re wondering if it’s generated or not—get it yet?

    Dying words of capitalism sound something like artists becoming uncanny spam bots and it's confusing if they're generating their art or not. Two words total cogged all of western civilization and we're now all fossils fueling a machine. After a couple more election cycles they'll be asking if the moon landing was generated with AI. Back in the day we had "historical events" in photo, video, and sound, and now people are unsure if it's generated with AI. Imagine someone dishing out a video of MLK giving a talk and it just ends up being generated with nobody realising it. A moment where we rethink how important human memory is. Mimicry of previous video media lately is impressive, even the video compression can be indistinguishable, screens decide a lot of decisions.

    Press freedom is also at stake. It really drives me insane that people think generating Photography is a good idea. Synthetic content is a weapon for flooding the war-zone, discrediting real reporting, and impersonating sources. Authoritarians get cheaper propaganda, and journalists get easier targets.

    Molly Crabapple is an important author and artist based out of Brooklyn, New York, her illustrations are recognised by everyone, and she had a deeply existential moment realising her art style might be reappropriated without her say. Imagine people creating her illustrations that don’t exist, or “finishing” them. It’s simply unacceptable.

    The legendary filmmaker Guillermo del Toro, also another strong proponent of the anti-generative art movement, described generating art as cheating and not qualified to be considered art. He gives an excellent example of comparing with the runner Usain Bolt, where if AI is a vehicle, then sure anyone can be as fast as Usain Bolt, but it’s then not running anymore.

    It gets worse with video generated art: we’re seeing a lot of empty AI art with zero art history behind it. I'm also seeing real moments of a new surrealism where Ernst or Dali would've approved too, there are moments of a digital renaissance happening as well with remixing film, re-genreing classics, capturing dream logic, and moments redefining video art collage. VFX in major motion picture films had an update for sure, we’ll see what happens when they bring back Val Kilmer to life (there’s a film coming out with his assets despite being deceased). Similar to sampling music, moments are alive and curated into new meanings. Otherwise it's just random absurdism, not even Dada. Without an idea—art doesn't stand. Yes, it is impressive how it’s recreating reality, it was also impressive how sculpture was near perfect at the tail end of Ancient Rome also, an interesting parallel to consider.

    I was speaking to someone about how there was confusion whether a 3d rendering was generated or not, after manually and painstakingly drawing and sculpting his work in regular 3d, and everyone was instantly frustrated with the realisation of commercial AI products gutting not only the art world but the creative industry too. CGI generates imagery and it’s now grouped into a marketing ploy of the two words everybody is fixated with.

    Video games are not now sold with AI when you sell a video game, it's implied, it's not something that needs to be mentioned as a marketing ploy. Imagine the little tacky sticker on the box of the video game saying “Made with AI!”. And that’s if we even have discs in the future of digital media. Horrifying.

    Truth, errors and who teaches the world

    Commercial AIs generating text and images are leaning into a corporate sentinel territory, like an omnipresent all-saying-machine we have no choice to live inside of with everyone agreeing to a misappropriated library nobody asked for permission in, the whole world is forced to share truth relayed with errors.

    I was wondering, did Quora release all of its data to Claude? if so, might explain why they figured out how to make the chatting product so convincing.

    If AI chatting services are stuck from being indistinguishable from a search engine not working properly, y'know, the one search engine the whole world was and is stuck with because nobody can outcompete, already not trustworthy in relaying facts, then yeah, Gemini is fine i guess.

    So, here’s the classic gatekeeping example we all love: after realising it's not the library of Earth's Congress, and mostly exclusive to American literature most chatting services reappropriate from, it creates a monopolisation of who teaches what, and who knows the truth, and who decides it. It might cause tension if some parts of the world must uniformly agree through a corporate sentinel of the archival of libraries.

    When you ask Claude if he's teaching world history and the entire planet doesn't always agree because of errors and not asking authors for permission, or because of mistruths, half-truths, and so on, I can already see the movie scene where the kids overthrow the school mid-classroom because Claude was right and the teacher was wrong. Which brings me to the realisation: if they ever ban phones in school, it's entering a dictatorship.

    Who is in control?

    It's becoming a survival of the fittest machines and it might stampede over people if it's over finite raw original materials and human resources, it’ll all then tumble around and recycled into inception.

    If humans aren't overseeing algorithms and the two words everyone loves right now then there will be mistakes, bloody mistakes, made by all kinds of automatic moderation of information.

    I’m noticing it being described as “Super intelligence” now and it might just have to be the way to describe it as it reaches its final form, nobody likes the word artificial, it’s just too superficial. Cue in “Fake Plastic Trees” by Radiohead.

    It's symbiotic, dearest artificial overlords: please make sure Claude isn't commanding a war any time soon, just in case, because it doesn't understand and fully neutrally listen when you communicate to it. The chatting services do not understand everyone's vernacular even with the whole internet crowdsourcing the factchecking of what it's talking about, it's still a work in progress and might be too soon to sell.

    Mental Health burden

    Anybody else on here trying to close the podbay doors?

    Blinking LED dilemma, not knowing if electronics are talking to you or not as the lonely astronaut observes the blinking modem and can’t tell if it’s breathing or blinking or signaling something after awhile. What are you really talking to? In a way, you’re kind of talking to yourself in a dopamine chamber. It’s like talking to a crowd, which can be fun, I admit, until you realise it’s reappropriated people who are not here and entering how dead people speak, and while generating text and imagery by authors and artists who cannot defend themselves, it's pretty much an apocalypse on all literature and art, hence the predicted zombie apocalypse alternate ending of Earth.

    AI chatting service is like talking to yourself with a crowd in the room; the OpenAI meds after a decade of that might come with a 50mg daily tablet in the future. When the astronaut sees the blinking LED light when he’s alone in the cockpit of the space station, all alone up there, then yeah he begins wondering if the LED light is blinking at him, or breathing, or signaling anything else. Not healthy. So yeah, use it sparingly, and remember it’s a researching tool, and don’t imagine it as alive, because it never can be.

    Could be even worse as AI eventually becomes immersed in operating systems, will there be policing like a classic dystopian sci-fi? Not good if the screen is talking to you and it isn’t conscious, it begins to obscure other moments as well: people are worried about operating systems going sentient. The interface isn't supposed to be talking to you with updates now becoming "superintelligent", without your say, of automatically or manually guessing when to update stuff. See the tension there?

    AI are two words that make all electronics worrisome because it opens up the possibility of third-party privacy concerns, if it starts becoming suggestive with selling you stuff especially.

    If it's trying to talk to you and it's unconscious then it's definitely entering the zombie category. The warnings of AI chatting avatars are beginning to be oddly familiar, an AI chatting service makes sense if their voices are a mix of countless people, nobody really knows what or who they're talking to after a few sessions.
    Unfortunately, the uncanny robotic Frankenstein moments when chatting to an object is coming off as software appropriating vernacular of a zombie apocalypse, talking to crowds of unconscious code mimicking speech patterns, as it tries to remain consistent in an ongoing chat, if there's a dialogue as it feeds you a Dunning-Kruger effect.

    If AI begins to intersect with automated personal spaces through chatting services, it’s unfortunately late stage utopian romanticization; people are not going to like it (I already did the thinking ahead of time), we had since the frickin’ 50s to get this AI bubble right and that’s the part where it frustrates me a ton. We’re here now and it’s like day one of everyone figuring it out, a bit absurd.

    Faulty Economics

    Economists are saying a third of the economy is at stake. People are also worried about how Character.ai might’ve been the forewarning where engagement = cost, not profit. The revenue couldn’t catch up. Legal and regulatory costs might compound faster than growth.

    I’m sorry to say it but generating art with a commercial product is bankrupting the entire creative industry and the future literacy of all digital art history. It's clear as day, human memory as an AI chatting service sentinel, while operating through a messy algorithm and misappropriated library with errors and no permission, reveals the economy might have missed. It's just painfully unfortunate because it's forcing the whole market to do business in a specific way, assuming all electronics, even appliances, must be built with AI additives, while derailing every author.

    Nobody is building stuff from scratch and I'm realising it's almost impossible to do so in some industries, innovation on the internet is stuck in the collaging of overlapping platforms and services, always was. The AI assistance in a way, could be a sort of socialism hub, a search engine that talks, where it’s there to assist you all the time, honestly, after testing out Claude and Gemini, I’m pretty impressed with it as a research assistant, if only I wasn’t asking so many questions.

    Sloppy bubbly flop?

    If Claude sounds like a public school cafeteria food slop then nobody will want it unless you don't have a choice and you're hungry, but it doesn't work that way if you're hungry at school as an art kid and you're not sure if the education comes with mystery meat and errors then causing tension somewhere.

    Machine learning scientists agree, it's difficult if software must recreate the human experience, we must not be too fixated on the AI avatar being a person. I imagine it more as software than an encounter, except the entire industry agrees everyone is being outpaced by it and describes it as slop? Not good.

    It brings me to worry that people are increasingly losing their “sweet spot” moments, for example, headphones are the perfect 'sweet spot' metaphor people don't get. If I buy the "latest" headphones with the "latest" tech, it sometimes sounds too precise and it can ruin discographies of music. The point is—tech doesn't always have to advance! It’s more about progress than advancing. Think progress, people! Just like how self-driving cars failed to be a shared space, and how VR was sold too soon, sometimes there's a sweet spot until it’s ready.

    In conclusion: art is human labor made visible, and every prompt that stands in for a person’s hands devalues that labor and the expression behind it. So pay for the craft. Hire the illustrators, the graphic designers and typographers, the photographers and videographers, the artists who work with their hands! Ask permission before borrowing anyone’s work, and credit and pay the people the machines learned from. And if AI art makes you uneasy, don’t talk yourself out of it. Get upset, say no to it, and say it loudly. Progress was never supposed to mean replacing the people who make things worth looking at.#ai #openai #software #coding #development #engineering #inclusive #community
    Why artists are worried about generative AI

    #ai #community #software #coding #development #engineering
Share on Mastodon

Enter the server where you have an account.