Tag Archives: Hipster

Keeping it all together

Posted on by

Our autonomous geological report agent sometimes finds interesting information that our users should be notified about, and given the opportunity (…) to create an opportunity in CRM without having to burn more calories than neccessary.

To achieve this, and to comply with the strict guardrails implemented by the company we work for, we had to utilize a quite alternative approach. 

In addition to creating a file in one our trusted SharePoint libraries, a record is written to a table in a storage account in a seperate – more relaxed – tenant… All this is done in a flow:

The flow:

Our awesome proactive bot – created using Teams SDK 2.0 in M365 Agents Toolkit  (🪦TeamsFX) will poll this table to see if there have been any new reports made. It will then send messages to users, and making sure a user only receives this notification once – to avoid spam…

Using adaptive cards, the user can choose to either ignore the findings or act upon them by creating an opportunity in CRM.

Adaptive Cards with limitless possibilities (once our map-generating service is ready)

Nvidia Jetson Nano

Posted on by

A big part of ACDC is experimenting with new ideas and technologies, even when the outcome is uncertain. As part of that, we set up an Nvidia Jetson Nano that may—or may not—end up as part of our final implementation.

What makes this device interesting is that it is an edge AI computing unit with very low power consumption (around 15–25W), yet still capable of running a local LLM.

We experimented with running Ollama using Gemma 3, exploring how a small, embedded model could be used in off-grid or low-connectivity scenarios. One potential use case is a locally deployed language model that interprets environmental data from sensors—such as soil conditions, temprature or image recognition—without relying on cloud services.

These boards are also used for robot applications and could potentially be the heart of our robot building houses in the real world.


The concrete use cases are still evolving, but the goal is clear:
to enable intelligent behavior at the edge, where power, connectivity, and infrastructure are limited.

It takes like 15mins to half an hour to resolve these promts, so we need patient customers..

acdc-badge-sniper / SKILL.md : An AI agent skill for Hackathon Strategy

Posted on by

We built an AI agent skill that helps ACDC teams identify their best badge targets and create action plans. It works with Claude Code, VS Code Copilot, and ChatGPT.

What it does

  • Fetches live ACDC data (badges, teams, claims, rankings)
  • Matches your project to optimal badge targets
  • Creates time-boxed checklists with evidence requirements
  • Generates 30-60 second judge pitch scripts

    Installation and usage

    Claude Code
    Drop the `acdc-badge-sniper` folder into your skills directory and invoke it.

    VS Code Copilot
    Copy `copilot-instructions.md` to `.github/copilot-instructions.md` in your project, or paste it directly into Copilot Chat.

    ChatGPT / OpenAI
    Use openai-system-prompt.md as your system prompt or Custom GPT instructions.

    Data sources
    The skill uses live ACDC data and updates regularly to reflect new badges and team standings!

    Quick start

    Tell your AI assistant:
    1. Your team name
    2. What you’ve built (2-6 bullets)
    3. Your stack (M365, Azure, Power Platform, etc.)
    4. Time remaining
    5. Constraints (no admin, no external APIs, shorthanded, etc.)

    It will return your top 5 badge targets with checklists, evidence requirements, and judge pitches.

    Get the skill
    https://github.com/Puzzlepart/ACDC-26/blob/main/skills/acdc-badge-sniper/SKILL.md

Screenshots!

META: creating the acdc-badge-sniper to snipe badges

By sharing this skill we aim for the following badges:

  • Sharing is Caring We made the badge-sniper available for other teams to use; it’s literally a shared tool.
  • Community Champion We didn’t just publish it; we’ll help teams set it up and use it, which is direct community support.
  • Hipster Agent skills + Claude Code / Copilot / ChatGPT workflows are bleeding‑edge dev tooling
  • Dataminer The skill fetches live ACDC blob data and converts raw JSON into ranked, actionable strategy.
  • Power User Love Tiny YAML + markdown config drives complex AI output: low‑code definition with pro‑code impact.
  • Plug N’ Play It plugs into VS Code Copilot via copilot-instructions.md, meeting “plugin/app” intent.

Lost Ancient Recipe Recovery Tool 

Posted on by

In our concept, the 3D printer becomes a modern crafting table. (ref post Crafting, Crafting, Crafting…. Category: Pro Code  | Arctic Cloud Developer Challenge Submissions)
Just like villagers in a game world, our Customers can rely on recipes to craft almost anything they want. But what happens when a recipe is lost, discontinued, or no longer available on the market – and all you have left is a broken spare part? 

That’s where Model Builder comes in. 

The Problem 

Spare parts often disappear long before the products that rely on them. When something breaks, users are left with: 

  • No original CAD files 
  • No replacement parts 
  • No way to reverse-engineer the object without expert tools 

The Idea 

Model Builder is a recovery tool for lost recipes. 

A screenshot of a computer AI-generated content may be incorrect. 
By using just one photo, the app helps users reconstruct a printable 3D model of a broken or unavailable object. 

How It Works 

  1. Upload a Single Photo 
    The user takes a picture of the broken item or spare part using their phone or camera. 
  1. Detail Enhancement 
    The app enhances edges, surfaces, and geometry, filling in missing or damaged details to make the object readable for modeling. 
  1. Model Generation Assistance 
    Based on the enhanced image, the tool assists in generating a clean, printable 3D model – ready to be refined or sent directly to the 3D printer. 
  1. Craft Again 
    The recovered “recipe” allows the user to recreate, repair, or improve the original object. 

The Vision 

Model Builder turns visual memory into manufacturable knowledge. 
Even when designs are lost to time or market changes, users regain the power to repair, recreate, and continue crafting – bringing true self-sufficiency to 3D printing. 

We are using the coolest technologies: Bun for the backend app, Gemini Nano Banana Api for Projection generation and Meshy.ai to generate the model from the projections.

Badge: Hipster

So hip it does not support IaC propperly

Posted on by

One of the hippest tech around right now might be Microsoft foundry. It has MCP, and agent integrations in a very easy UI friendly way.

We use Microsoft foundry Workflows to make multi agent conversations that check Compliance, risk, and other things we might need a multi agent flow for.

Why multi agent. Agents are confidently wrong sometimes, we therefor step inn as humans when in a one to one conversation and tell it to “check that again”. But what if we had a agent that had its entire job to argue with the reasoning, quality, and accuracy of the other agents and make them try again to justify their answers. This is why multi agent flows may be better at providing correct answers.

But the agent-foolery does not stop there. When our data reaches Fabric we can use fabric data agents to ground the reasoning for our multi agent flows. The fabric data agent has the ability to do queries in fabric, and figure out complex questions, and provide a data driven answer. Now THAT is hip.

Most of these resources are directly API compatible, and can be in some way or form be directly integrate with Terraform. but some need dirty workarounds because sometimes we fool with tech that is so hip it does not have a API.

We are also atempting to claim The Existential Risk badge with this post.

Our agents does have guardrails. Jailbreak is a part of this and should handle attempts at injecting commands inn to the permit application.

Testing this proved that when it can argue why it should not follow the instructions it will, but when it decides that it is “grounds for blocking” it will also do that.

Warp + MCP + Devops = Hispter

Posted on by

We added a MCP server to WARP. So that we can use generative AI to:

  • Add tasks and user stories.
  • Link badges to tasks and user stories.
  • Link code to user stories and tasks.
  • Do pull requests.
  • Write documentation.
  • Run pipelines.
  • And much more.
{
  "mcpServers": {
    "ado": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@azure-devops/mcp", "acdc2026"]
    }
  }
}

Mcp server with tools available:

Added work items:

Devops:

Less blocks. More vibes.

Posted on by

A Raspberry Pi. #Hipster

Small. Metallic. Minimal.

The kind of computer you’d proudly place next to a houseplant and an oat-milk latte.

Minimalism is hip. Post-modern architecture and interior design celebrate small, intentional choices over excess  and we applied the same thinking to our tech.

 By hosting our Minecraft server and backend on a Raspberry Pi, we chose a tiny, portable, minimalist computer instead of heavy infrastructure. It takes up no space, can go anywhere, and proves that modern solutions don’t need to be big to be cool. Trendy, intentional, and unapologetically minimal:

The Raspberry Pi isn’t just a prop. It works:

  • It runs our Minecraft world
  • It hosts the logic that connects gameplay data to business processes
  • It proves that modern solutions don’t have to be bloated to be brilliant

Why This Is Peak Hipster 🕶️

  • Minimal footprint = physically and philosophically
  • Portable by design = hackathon today, cabin in the woods tomorrow, in a cave yesterday
  • Edge-first thinking = not everything needs a hyperscale cloud
  • Aesthetic infrastructure = aaaaand yes, that’s a thing now

and that’s why we deserve the Hipster badge.

Why we Deserve the Embedding Numbnuts badge

To prove we weren’t just moving bits inside a virtual world, we let our solution reach out and touch real hardware.

Using a Raspberry Pi, we integrated a physical device directly into the flow of our solution. Without it we would have to host the server on our own device….boring. Its our very own Crafting Table. Just a small, slightly overworked Raspberry Pi acting as the messenger between blocks, bots, and reality.

It’s unnecessary. It’s excessive. It flips bits in the real world.
Which makes it exactly the kind of thing Embedding Numbnuts was meant for. 🥜

(Written by a 25 year old…..)

_______

Cepheo Crafting Creepers *sipping their matcha*

No API, no problem

Posted on by

Don’t you just love when you are toying around with the newest Microsoft features and want to integrate it inn to your Terraform code, and realize the feature does not support API at all.

This is the feeling of love i felt when atempting to deploy Microsoft foundry workflows with the use of Terraform.

Giving up at this stage is not really a option since scaling the infrastructure is a priority. So how do one solve such a issue?

The solution is to go to your browser, and monitor exactly what data goes inn and out, and catch the exact POST request you need.

Then you make a dirty powershell script that does that post request for you, with the payload you want.

Lastly you need the powershell code to be invoked by the Terraform code with local exec.

It may not be the prettiest solution to implement IaC to whatever solution you want. But the result speaks for itself, IaC on a solution that is “UI only”.

This may be as dirty a hack can get, but what else can you do when one is using so hip technology that not even Microsoft has a API for it.

Reactive simplicity

Posted on by

In addition to our API, the nr. 1 howler service also has a website. It is built using React Router, with an impeccable developer-experience with hot-reloading, react hooks, sass, and more!

Using GitHub Secrets and Workflows ensures secure handling of sensitive information through encryption and access control. As an example from the github-actions yml-file: azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN_THANKFUL_HILL_0CC449203 }}

Update Your ALM – The Hipster Way

Posted on by

🧑‍💻 Update Your ALM – The Hipster Way 🎩

In the world of Application Lifecycle Management (ALM), being a hipster isn’t just about wearing glasses and drinking artisanal coffee. ☕ It’s about using the latest tech and best practices to ensure your solutions are compliant, governed, and respectful of privacy. Here’s how we’ve upgraded our ALM setup to be as sleek and modern as a barista’s latte art. 🎨

🌟 Delegated Deployment with SPNs

The backbone of our ALM setup is delegated deployment using a Service Principal (SPN). This ensures that our deployment process is:

  • Secure: Using the SPN credentials, we minimize risks of unauthorized access.
  • Streamlined: Delegated deployment allows automation without compromising governance.

Key configuration steps:

  1. Set “Is Delegated Deployment” to Yes.
  2. Configure the required credentials for the SPN.

UAT:

PROD:

📜 Approval Flows for Deployment

Governance is king 👑, and we’ve built a solid approval process to ensure that no deployment goes rogue:

  1. Triggering the Approval:
    • On deployment start, a flow triggers the action “OnApprovalStarted”.
    • An approval request is sent to the administrator in Microsoft Teams.
  2. Seamless Collaboration:
    • Once approved, the deployment process kicks off.
    • If rejected, the process halts, protecting production from unwanted changes.

📢 Teams Integration: Keeping Everyone in the Loop

Adaptive Cards are the stars of our communication strategy:

  1. Monitoring Deployments:
    • Each deployment sends an adaptive card to the “ALM” channel in Microsoft Teams.
    • Developers and stakeholders can easily follow the deployment routine in real-time.
  2. Error Alerts:
    • If a deployment fails, an error flow triggers and sends a detailed adaptive card to the same channel.
    • This ensures transparency and swift troubleshooting.
  3. Release Notes:
    • Upon a successful production deployment, a flow automatically posts an adaptive card in the “Release Notes” channel.
    • End users can see the latest updates and enhancements at a glance.

🛡️ Why This Matters

Our upgraded ALM setup doesn’t just look cool—it delivers real business value:

  • Compliance: Ensures all deployments follow governance policies.
  • Privacy: Protects sensitive credentials with SPN-based authentication.
  • Efficiency: Automates processes, reducing manual intervention and errors.
  • Transparency: Keeps all stakeholders informed with real-time updates and error reporting.

💡 Lessons from the ALM Hipster Movement

  1. Automation is Key: From approvals to error handling, automation reduces the risk of human error.
  2. Communication is Power: Integrating Teams with adaptive cards keeps everyone in the loop, fostering collaboration.
  3. Governance is Non-Negotiable: With SPNs and approval flows, we’ve built a secure and compliant deployment pipeline.

🌈 The Cool Factor

By blending cutting-edge tech like adaptive cards, Power Automate flows, and Teams integration, we’ve turned a routine ALM process into a modern masterpiece. It’s not just functional—it’s stylish, efficient, and impactful.