An accountability buddy should make a hard promise easier to keep, not turn your week into a status meeting. The right person knows the goal, sees the proof that fits it, and has a fair answer ready when the day goes sideways.

PactBuddy is built around that smaller relationship. One person makes a pact with one buddy. The owner gets a clear way to check in. The buddy gets one decision to make when proof arrives. Everything else is noise.

An accountability buddy should have one job

Choose the person who will ask a useful question after a miss. That may be a close friend, a coworker, or someone you already trust with a specific goal. It does not have to be the person who gives the best pep talks.

The job is narrow: know what was agreed, wait for the right proof, and respond when the check-in is ready. PactBuddy makes that role explicit in the incident view:

enum IncidentViewerAction: Equatable {
    case submitProof
    case waitForOwnerProof
    case waitForBuddyReview
    case reviewProof
    case none
}

The owner submits proof. The buddy waits, then reviews it. Neither person has to guess which side of the conversation they are on. That division keeps a daily goal from becoming a vague request for constant motivation.

A good accountability buddy needs a goal they can understand

"Be healthier" is a value. It is not a check-in. Your accountability buddy needs a target that both of you can recognize before the first deadline arrives.

PactBuddy keeps the target, cadence, count, and local deadline together in its custom goal model:

public struct CustomGoalConfig: Codable, Sendable, Hashable {
    public var title: String
    public var `operator`: Operator
    public var targetValue: Int
    public var unit: String
    public var cadence: String
    public var targetCount: Int
    public var deadlineLocal: String
}

That turns "work out more" into "work out three times by Sunday at 6 p.m." The goal can still be personal. It just needs a shape your buddy can understand without a second meeting.

The same idea sits at the center of how an accountability pact handles the goal before the first miss. Agree on the target while the conversation is easy. You will not want to invent the rules at 10 p.m. on a bad day.

Proof should answer one question and stop

The best proof is the smallest proof that settles the agreed question. A wake-up goal may need a selfie. A workout may need a photo. A Screen Time goal may need a rounded result instead of a report about every app on the phone.

The app keeps those proof paths separate:

struct ProofSubmission: Sendable, Hashable {
    enum Method: String, Sendable, CaseIterable {
        case wakeSelfie = "wake_selfie"
        case photo
        case screentimeSync = "screentime_sync"
        case manual
    }
}

This gives an accountability buddy something specific to review. It also sets a privacy limit. The person does not hand over a whole diary to prove one thing happened. The Screen Time accountability app guide explains that boundary in detail. PactBuddy uses Apple's Family Controls framework for the device-level permission behind that narrow result.

An accountability buddy should not monitor you all day

Constant visibility sounds like accountability until both people start avoiding it. A buddy should receive the result that belongs to the pact, not a live feed of your choices.

PactBuddy gives the agreement a cadence and quiet-hour settings. The current product contract keeps the reminder floor at 900 seconds, allows a one-hour owner snooze up to three times per incident, and lets a person stop their own open pager. Those limits matter because a buddy is still a person with a life outside the goal.

The settings stay explicit in the shared model:

struct PactSettings: Sendable, Hashable {
    var pageIntervalSec: Int
    var quietHoursEnabled: Bool
    var quietHoursStart: String?
    var quietHoursEnd: String?
    var isPaused: Bool
}

Before you ask someone to be your accountability buddy, agree on when a check-in can arrive and when it should wait. A clear boundary makes a hard question easier to answer.

A missed day shows whether the buddy is a fit

You do not learn much from the first easy week. The useful test comes after the missed deadline. Can your buddy ask what happened without turning the answer into a trial? Can you submit proof without feeling watched? Can both of you adjust the goal when the setup was wrong?

PactBuddy treats a miss as an incident with a next action. The owner can submit proof, the buddy can confirm or reject it, and a weekly vouch can excuse the day. The product records a response instead of leaving the relationship with a red square and an awkward text.

The weekly recap then gives the pair a smaller review. It shows kept, missed, and in-flight check-ins for the current calendar week, so a goal due tomorrow does not count against today. The weekly goal review covers why that distinction matters.

What an accountability buddy cannot do

An accountability buddy cannot want the goal for you. They cannot make an unreliable plan work, and they cannot decide whether a goal still fits your life. An app cannot solve those problems either.

That is why the agreement should stay small. Pick one goal. Decide what counts as proof. Set the deadline. Write down what happens after a miss. If the plan fails, change the plan before you blame the person.

Start with a request your buddy can answer

Ask one person this:

"Will you help me keep one goal for the next two weeks? I will check in by 7 p.m. with [proof]. If I miss, please ask me once what happened. If the goal no longer fits, we will change it together."

That is enough to find out whether the relationship has room for an accountability buddy role. If the answer is yes, make the first promise specific and give both people an easy way to close the loop.