Collecting form responses is one thing, but once you try to use them, a lot of them turn out to be unusable. Some are missing critical information or answering the wrong question (think but report with no steps to reproduce, support queries suffering from the XY problem [1], etc.). Classic required fields and regex validation help with syntax, but they can't tell you whether the answer actually makes sense for what you need to do with them.

I built a Google Forms add-on that lets you describe what a good answer looks like in plain text ("should say what they were doing when the issue happened", "should explain what they tried before reaching out", "should be specific, not just say it doesn't work") and then automatically emails gentle feedback to each respondent after they submit, with a submission update button. If the next submission still falls short, they hear from it again. It stops when you say it's good enough, or when you turn it off.

Of course, this doesn't prevent computer-generated SPAM, if the spammers learn to automatically send actionable and clear responses, but see [2].

A couple surprising things:

- Responders are more willing to update their submissions than you'd expect, as long as the feedback is tailored and specific, which this helps with.

- Some people engage with AI feedback more readily than with human comments. Maybe because it doesn't feel personal?

- Writing the feedback instructions in the setup wizard is useful by itself. You frequently realize that you were asking the wrong questions on the form, and didn't make yourself clear enough.

The AI writes the email based on your instructions. You can calibrate on a few test submissions to make sure you're not being too lax or too annoying. You can bring your own Gemini key, but it is not required. It hooks into the Forms submit trigger and sends email through the Gmail service by default. It's available on the add-on directory [3].

[1] https://xyproblem.info/

[2] https://xkcd.com/810/

[3] https://workspace.google.com/marketplace/app/ai_response_fee...

Comments URL: https://news.ycombinator.com/item?id=48551311

Points: 2

# Comments: 0

I built something I've been wanting for years: a way to access the power of Google Apps Script inside Sheets on demand, without having to switch to the code editor and remembering Apps Script APIs.

## Why bother?

Apps Script is actually underrated: it lets you do arbitrary structured logic (when formulas get unreadable/convoluted), procedural transformations, and even add custom UIs (menus, dialogs, sidebars). It goes further than macros, with triggers, etc.

But the pain is real: remembering the APIs, figuring out deployment, debugging code in an unfamiliar environment, etc. For non-technical folks, it’s simply inaccessible.

## What Kyran does

It lives as a Sheets add-on (sidebar). You describe what you want, it generates Apps Script code, installs it into your Sheet, and you can run it right away.

You can iterate in the "spreadsheet-native" way: not by reading the code, but by trying it on some data and checking the result. If it's wrong, you tweak the description.

The code it generates is short (usually <50 lines), uses a very limited API surface, and can be tested quickly. That makes the usual risks of AI hallucination far less of an issue in practice than in general-purpose coding.

## What I love (technically) about this

It's a narrow domain where AI codegen actually works rather reliably: small programs, well-defined APIs, immediate execution in a data-rich context.

It matches how people already use spreadsheets: experiment -> check results -> adjust. People asking for formula help on the internet don't usually try to decipher the monstrosities given to them, and you don't need to read the code here either. The code is running in a very tight sandbox Google spent a lot of time improving, and it's even more restricted for our use case.

For power users, it's essentially "vibe coding" Apps Script: you still end up with real code, just without the boilerplate and deployment tax. For others, it just makes possible something they could only dream of.

I've been trying it on Google Sheets forum posts asking for help, and it works great.

## Who might care

- Spreadsheet power users who regularly outgrow formulas.

- Engineers who hate chasing docs just to write 30 lines of Apps Script for a one-off task

- Ops/analyst teams that hack Sheets together as their internal "apps."

## Limitations

The scripts you create inherit the permissions of the Kyran add-on itself. Apps Script can control a lot of other Google Apps, including Drive, but I don't want to scare people away with a huge permission prompt.

This is therefore currently limited to manipulating the current sheet only. I hope the permission model for add-ons evolves so I can ask for any permission (like calendar access) at the exact point where user generated code needs it.

## Links

[Homepage / docs](https://blog.darkaa.com/kyran-ai-app-builder-for-sheets-user...)

[Add-on install](https://workspace.google.com/marketplace/app/kyran_ai_app_bu...)

You get some free requests, and can add your Gemini API key for more.

Yes, this has massive platform risk. Sanity is not something I can afford right now ;)

Would love feedback, especially from folks who've wrestled with Apps Script before.

Comments URL: https://news.ycombinator.com/item?id=45092787

Points: 1

# Comments: 0

If you care about reliability, there's no way around scanning the codes yourself (instead of making attendees scan), so you can be sure that each scan maps to an actual attendee, and you're not getting 30 scans from 10 people actually present.

I guess self-check-in became popular in zoom calls during the covid area, but people that need reliability instantly prefer the alternative, when available.

Shameless self-plug: this is precisely why my Google Forms/Sheets check-in plugin is named "Qr code ticket per attendee" [1], because the unique ID per person is what makes it more reliable than self-check-in.

Yes, people can still send friends, but most of the time, you don't care, and it's too much of a hassle for the attendee. People sometimes worry that check-in won't be quick, but QR code reading is very fast [2], and you're only limited by how quick people move.

[1] https://qr-code-ticket.com

[2] https://www.youtube.com/watch?v=-fkgCX3H7so

[1] https://news.ycombinator.com/item?id=39094251

I used this for digital QR code tickets [2], and it made the codes so much easier to scan, even with bad lighting.

[1] https://news.ycombinator.com/item?id=39094251

[2] https://workspace.google.com/marketplace/app/qr_code_ticket_...

https://workspace.google.com/marketplace/app/qr_code_loyalty...

You create a new member by filling a Google Form (they receive a digital member card with a QR code by email), and add or subtract points by scanning the QR code.

This is very convenient when you control the QR reader and need to represent long numeric identifiers like UUIDs.

For example:

  9728983f-7d7d-4189-b624-f92781e36650 (lowercase UUID):
    => length=36, 15 pixels between markers
  JWM9GFVXFN0RKDH4Z4KR3RV6A0 (base32 UUID):
    => length=26, 11 pixels between markers
  9728983F-7D7D-4189-B624-F92781E36650 (uppercase UUID):
    => length=36, 11 pixels between markers
  200924207194334734815443970355691218512 (decimal UUID):
    => length=39, 7 pixels between markers

The decimal UUID is a longer string, but results in much bigger pixels because it can use numeric encoding.

I have a QR code base attendance tracker [1], where attendees show the code [2] on their phones (glares, etc.), in bad lighting conditions, etc. Bigger pixels means scanning stays quick. Same with parcel tracking [3] where field agents might need to scan QR codes in barely-lit hallways, etc.

[1] https://workspace.google.com/marketplace/app/qr_code_pass_fo...

[2] https://share.darkaa.com/!qntvtzNPWJ

[3] https://admin.trak.codes/

The Forms and Sheets add-ons are just customer acquisition channels, just like our Zapier integration [1]. These mostly use our API, and very little of our UI (mostly the scanner).

[1] https://zapier.com/apps/trak-qr-automation/integrations

[1] https://admin.trak.codes/

Great use case! I did a tool inventory management use case once, with the underlying platform [1].

It starts with generating QR codes for sticker papers [2], from the app. Those never expire and are all different (v4 UUID). You can then assign a QR to any new item, then scan it for registration in the app, specifying room, drawer, etc. (and gps, picture, etc. if needed).

You can browse tools per room, drawer, etc., and scan anytime to record an update. Each tool gets a history trail.

You can even make data-entry easier by making special QR codes for drawers; scanning them fills some form fields with presets, so you don't have to manually select stuff and make mistakes.

I mostly see use-cases where other people scan a QR you made, but there are use cases where the QR codes are only ever scanned by you and your staff.

[1] https://admin.trak.codes/ [2] https://share.darkaa.com/!9DXEQQTg2z/trak-qr-codes-demo-hn.p...

[1] https://news.ycombinator.com/item?id=38786113

The main platform is currently used by national post offices (physical mail tracking), health organizations (biological samples), banks (fixed assets tracking), manufacturing plants (parts inventory tracking), etc.

QR codes make it easy to avoid data-entry errors in quite a large set of use cases with physical objects.